单片机学习笔记————51单片机实现操作AT24C02时,利用“一气呵成的定时器延时”改善数码管的闪烁现象

时间:2020-08-08
本文章向大家介绍单片机学习笔记————51单片机实现操作AT24C02时,利用“一气呵成的定时器延时”改善数码管的闪烁现象,主要包括单片机学习笔记————51单片机实现操作AT24C02时,利用“一气呵成的定时器延时”改善数码管的闪烁现象使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

一、使用proteus绘制简单的电路图,用于后续仿真

关于IIC的读写:

二、编写程序

/********************************************************************************************************************
----	@Project:	AT24C02
----	@File:	main.c
----	@Edit:	ZHQ
----	@Version:	V1.0
----	@CreationTime:	20200722
----	@ModifiedTime:	20200722
----	@Description:	实现功能:
----	4个被更改后的参数断电后不丢失,数据可以保存,断电再上电后还是上一次最新被修改的数据。如果AT24C02短路,虚焊,或者坏了,系统可以检查出来,并且蜂鸣器会间歇性鸣叫报警。按更改参数按键时,数码管比上一节大大降低了闪烁现象。
----	显示和独立按键部分根据数码管显示程序来改编,S1,S5,S9作为独立按键。
----	一共有4个窗口。每个窗口显示一个参数。
----	第8,7,6,5位数码管显示当前窗口,P-1代表第1个窗口,P-2代表第2个窗口,P-3代表第3个窗口,P-4代表第1个窗口。
----	第4,3,2,1位数码管显示当前窗口被设置的参数。范围是从0到9999。S1是加按键,按下此按键会依次增加当前窗口的参数。S5是减按键,按下此按键会依次减少当前窗口的参数。S9是切换窗口按键,按下此按键会依次循环切换不同的窗口。
----	单片机:AT89C52
********************************************************************************************************************/
#include "reg52.h"
/*——————宏定义——————*/
#define FOSC 11059200L
#define BAUD 9600
#define T1MS (65536-FOSC/12/500)   /*0.5ms timer calculation method in 12Tmode*/

#define	OP_READ	0xa1		/*器件地址以及读取操作,0xa1即为1010 0001B*/
#define	OP_WRITE 0xa0		/*器件地址以及写入操作,0xa0即为1010 0000B*/

#define	const_key_time1 9	/*按键去抖动延时的时间*/
#define	const_key_time2 9	/*按键去抖动延时的时间*/
#define	const_key_time3 9	/*按键去抖动延时的时间*/

#define const_eeprom_1s 96	/* 大概1秒的时间 */

#define const_voice_short 20	/*蜂鸣器短叫的持续时间*/

/*——————变量函数定义及声明——————*/
/*蜂鸣器的驱动IO口*/
sbit BEEP = P2^7;
/*LED*/
sbit LED = P3^5;

/*按键*/
sbit Key_S1 = P0^0;	/*对应S1键,加键*/
sbit Key_S2 = P0^1;	/*对应S5键,减键*/
sbit Key_S3 = P0^2;	/*对应S9键,切换窗口*/
sbit Key_Gnd = P0^4;

/*数码管*/
sbit Dig_Hc595_Sh = P2^0;
sbit Dig_Hc595_St = P2^1;
sbit Dig_Hc595_Ds = P2^2;

/*EEPROM*/
sbit eeprom_scl_dr = P3^7;	/*时钟线*/
sbit eeprom_sda_dr_sr = P3^6;	/*数据的输出线和输入线*/

unsigned char ucKeySec = 0; /*被触发的按键编号*/
unsigned int uiKeyTimeCnt1 = 0; /*按键去抖动延时计数器*/
unsigned char ucKeyLock1 = 0;   /*按键触发后自锁的变量标志*/
unsigned int uiKeyTimeCnt2 = 0; /*按键去抖动延时计数器*/
unsigned char ucKeyLock2 = 0;   /*按键触发后自锁的变量标志*/
unsigned int uiKeyTimeCnt3 = 0; /*按键去抖动延时计数器*/
unsigned char ucKeyLock3 = 0;   /*按键触发后自锁的变量标志*/

unsigned int uiVoiceCnt = 0;    /*蜂鸣器鸣叫的持续时间计数器*/
unsigned char ucVoiceLock = 0;  /*蜂鸣器鸣叫的原子锁*/

unsigned char ucDigShow8;   /*第8位数码管要显示的内容*/
unsigned char ucDigShow7;   /*第7位数码管要显示的内容*/
unsigned char ucDigShow6;   /*第6位数码管要显示的内容*/
unsigned char ucDigShow5;   /*第5位数码管要显示的内容*/
unsigned char ucDigShow4;   /*第4位数码管要显示的内容*/
unsigned char ucDigShow3;   /*第3位数码管要显示的内容*/
unsigned char ucDigShow2;   /*第2位数码管要显示的内容*/
unsigned char ucDigShow1;   /*第1位数码管要显示的内容*/

unsigned char ucDigDot8;   /*数码管8的小数点是否显示的标志*/
unsigned char ucDigDot7;   /*数码管7的小数点是否显示的标志*/
unsigned char ucDigDot6;   /*数码管6的小数点是否显示的标志*/
unsigned char ucDigDot5;   /*数码管5的小数点是否显示的标志*/
unsigned char ucDigDot4;   /*数码管4的小数点是否显示的标志*/
unsigned char ucDigDot3;   /*数码管3的小数点是否显示的标志*/
unsigned char ucDigDot2;   /*数码管2的小数点是否显示的标志*/
unsigned char ucDigDot1;   /*数码管1的小数点是否显示的标志*/

unsigned char ucDigShowTemp = 0;	/*临时中间变量*/
unsigned char ucDisplayDriveStep = 1; /*动态扫描数码管的步骤变量*/

unsigned char ucWd1Update = 1;	/*窗口1更新显示标志*/
unsigned char ucWd2Update = 0;	/*窗口2更新显示标志*/
unsigned char ucWd3Update = 0;	/*窗口3更新显示标志*/
unsigned char ucWd4Update = 0;	/*窗口4更新显示标志*/
unsigned char ucWd = 1;	/*本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。*/
unsigned int uiSetData1 = 0;	/*本程序中需要被设置的参数1*/
unsigned int uiSetData2 = 0;	/*本程序中需要被设置的参数2*/
unsigned int uiSetData3 = 0;	/*本程序中需要被设置的参数3*/
unsigned int uiSetData4 = 0;	/*本程序中需要被设置的参数4*/

unsigned char ucTemp1 = 0;	/*中间过渡变量*/
unsigned char ucTemp2 = 0;	/*中间过渡变量*/
unsigned char ucTemp3 = 0;	/*中间过渡变量*/
unsigned char ucTemp4 = 0;	/*中间过渡变量*/

unsigned char ucDelayTimerLock = 0;	/* 原子锁 */
unsigned int uiDelayTimer = 0;

unsigned char ucCheckEeprom = 0;	/* 检查EEPROM芯片是否正常 */
unsigned char ucEepromError = 0;	/* EEPROM芯片是否正常的标志 */

unsigned char ucEepromLock = 0;	/* 原子锁 */
unsigned int uiEepromCnt = 0;	/* 间歇性蜂鸣器报警的计时器 */	

void Dig_Hc595_Drive(unsigned char, unsigned char);

/*根据原理图得出的共阴数码管字模表*/
code unsigned char Dig_Table[] =
{
	0x3f,  /*0       序号0*/
	0x06,  /*1       序号1*/
	0x5b,  /*2       序号2*/
	0x4f,  /*3       序号3*/
	0x66,  /*4       序号4*/
	0x6d,  /*5       序号5*/
	0x7d,  /*6       序号6*/
	0x07,  /*7       序号7*/
	0x7f,  /*8       序号8*/
	0x6f,  /*9       序号9*/
	0x00,  /*不显示  序号10*/
	0x40,  /*-		 序号11*/
	0x73,  /*P       序号12*/	
};

/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  /*内嵌循环的空指令数量*/
          {
             ; /*一个分号相当于执行一条空语句*/
          }
   }
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void delay_short(unsigned int uiDelayShort)
{
  unsigned int i;
  for(i=0;i<uiDelayShort;i++)
  {
		 ; /*一个分号相当于执行一条空语句*/
  }
}

/**
* @brief  延时函数
* @param  uiDelayTimerTemp
* @retval 无
**/
void delay_timer(unsigned int uiDelayTimerTemp)
{
	ucDelayTimerLock = 1;
	uiDelayTimer = uiDelayTimerTemp;
	ucDelayTimerLock = 0;
/* 
*延时等待,一直等到定时中断把它减到0为止.这种一气呵成的定时器方式,
*可以在延时的时候动态扫描数码管,改善数码管的闪烁现象
*/
	while(uiDelayTimer != 0);	/* 一气呵成的定时器方式延时等待 */	
}

/**
* @brief  EEPROM出错报警
* @param  无
* @retval 无
**/
void eeprom_alarm_service(void)
{
	if(ucEepromError == 1)	/* EEPROM出错 */
	{
		if(uiEepromCnt < const_eeprom_1s)
		{
			ucEepromLock = 1;
			uiEepromCnt = 0;	/* 计时器清零 */
			ucEepromLock = 0;

			ucVoiceLock = 1;
			uiVoiceCnt = const_voice_short;
			ucVoiceLock = 0;
		}	
	}
}

/**
* @brief  开始数据传送函数
* @param  无
* @retval 开始位
**/
void start24(void)
{
	eeprom_sda_dr_sr = 1;
	eeprom_scl_dr = 1;
	delay_short(15);
	eeprom_sda_dr_sr = 0;
	delay_short(15);
	eeprom_scl_dr = 0;
}

/**
* @brief  结束数据传送函数
* @param  无
* @retval 结束位
**/
void stop24(void)
{
	eeprom_sda_dr_sr = 0;
	eeprom_scl_dr = 1;
	delay_short(15);
	eeprom_sda_dr_sr = 1;
}

/**
* @brief  确认位时序函数
* @param  无
* @retval 检测应答
**/
void ack24(void)
{
	eeprom_sda_dr_sr = 1;
	eeprom_scl_dr = 1;
	delay_short(15);
	eeprom_scl_dr = 0;
	delay_short(15);
}

/**
* @brief  读函数
* @param  无
* @retval 读取一个字节的时序
**/
unsigned char read24(void)
{
	unsigned char outdata, tempdata;
	outdata = 0;
	eeprom_sda_dr_sr = 1;	/*51单片机的IO口在读取数据之前要先置一,表示数据输入*/
	delay_short(2);
	for(tempdata = 0; tempdata < 8; tempdata ++)
	{
		eeprom_scl_dr = 0;
		delay_short(2);
		eeprom_scl_dr = 1;
		delay_short(2);
		outdata = outdata << 1;
		if(eeprom_sda_dr_sr == 1)
		{
			outdata ++;
		}
		eeprom_sda_dr_sr = 1;
		delay_short(2);
	}
	return(outdata);
}

/**
* @brief  写函数
* @param  dd
* @retval 发送一个字节的时序
**/
void write24(unsigned char dd)
{
	unsigned char tempdata;
	for(tempdata = 0; tempdata < 8; tempdata ++)
	{
		if(dd >= 0x80)
		{
			eeprom_sda_dr_sr = 1;
		}
		else
		{
			eeprom_sda_dr_sr = 0;
		}
		dd = dd <<1;
		delay_short(2);
		eeprom_scl_dr = 1;
		delay_short(4);
		eeprom_scl_dr = 0;
	}
}

/**
* @brief  读函数
* @param  address
* @retval 从一个地址读取出一个字节数据
**/
unsigned char read_eeprom(unsigned char address)
{
	unsigned char dd, cAddress;
	cAddress = address;	/*把低字节地址传递给一个字节变量。*/

	EA = 0;	/*禁止中断*/
	start24();	/*IIC通讯开始*/
	write24(OP_WRITE);	/*此字节包含读写指令和芯片地址两方面的内容。*/
						/*指令为写指令。地址为"000"的信息,此信息由A0,A1,A2的引脚决定*/
	ack24();	/*发送应答信号*/
	write24(cAddress);	/*发送读取的存储地址(范围是0至255)*/
	ack24();	/*发送应答信号*/

	start24();
	write24(OP_READ);	/*此字节包含读写指令和芯片地址两方面的内容。*/
						/*指令为读指令。地址为"000"的信息,此信息由A0,A1,A2的引脚决定*/	
	ack24();	/*发送应答信号*/	
	dd = read24();	/*读取一个字节*/
	ack24();	/*发送应答信号*/
	stop24();	/*停止*/

	EA = 1;	/*允许中断*/
	delay_timer(2);	/* 一气呵成的定时器延时方式,在延时的时候还可以动态扫描数码管 */
	return(dd);
}

/**
* @brief  写函数
* @param  address, dd
* @retval 往一个地址存入一个字节数据
**/
void write_eeprom(unsigned char address, unsigned char dd)
{
	unsigned char cAddress;	
	cAddress = address;	/*把低字节地址传递给一个字节变量。*/

	EA = 0;	/*禁止中断*/
	start24();	/*IIC通讯开始*/
	write24(OP_WRITE);	/*此字节包含读写指令和芯片地址两方面的内容。*/
						/*指令为写指令。地址为"000"的信息,此信息由A0,A1,A2的引脚决定*/
	ack24();	/*发送应答信号*/
	write24(cAddress);	/*发送读取的存储地址(范围是0至255)*/
	ack24();	/*发送应答信号*/
	write24(dd);	/*写入存储的数据*/
	ack24();	/*发送应答信号*/
	stop24();	/*停止*/	
	EA = 1;	/*允许中断*/
	delay_timer(4);	/* 一气呵成的定时器延时方式,在延时的时候还可以动态扫描数码管 */
}

/**
* @brief  读函数
* @param  address
* @retval 从一个地址读取出一个int类型的数据
**/
unsigned int read_eeprom_int(unsigned int address)
{
	unsigned char ucReadDataH;
	unsigned char ucReadDataL;
	unsigned int uiReadDate;

	ucReadDataH = read_eeprom(address);	/*读取高字节*/
	ucReadDataL = read_eeprom(address + 1);	/*读取低字节*/

	uiReadDate = ucReadDataH;	/*把两个字节合并成一个int类型数据*/
	uiReadDate = uiReadDate <<8;
	uiReadDate = uiReadDate + ucReadDataL;

	return(uiReadDate);
}

/**
* @brief  写函数
* @param  address, uiWriteData
* @retval 往一个地址存入一个int类型的数据
**/
void write_eeprom_int(unsigned int address, unsigned int uiWriteData)
{
	unsigned char ucWriteDataH;
	unsigned char ucWriteDataL;

	ucWriteDataH = uiWriteData >>8;
	ucWriteDataL = uiWriteData;

	write_eeprom(address, ucWriteDataH);	/*存入高字节*/
	write_eeprom((address + 1), ucWriteDataL);	/*存入低字节*/
}

/**
* @brief  定时器0初始化函数
* @param  无
* @retval 初始化T0
**/
void Init_T0(void)
{
	TMOD = 0x01;                    /*set timer0 as mode1 (16-bit)*/
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
}

/**
* @brief  外围初始化函数
* @param  无
* @retval 初始化外围
* 让数码管显示的内容转移到以下几个变量接口上,方便以后编写更上一层的窗口程序。
* 只要更改以下对应变量的内容,就可以显示你想显示的数字。
**/
void Init_Peripheral(void)
{
	ucDigDot8 = 0;  
	ucDigDot7 = 0; 
	ucDigDot6 = 0; 
	ucDigDot5 = 0;   
	ucDigDot4 = 0;
	ucDigDot3 = 0;   
	ucDigDot2 = 0;  
	ucDigDot1 = 0; 
	ET0 = 1;/*允许定时中断*/
	TR0 = 1;/*启动定时中断*/
	TR1 = 1;
	ES = 1;	/*允许串口中断*/
	EA = 1;/*开总中断*/  

/* 
* 检查AT24C02芯片是否存在短路,虚焊,芯片坏了等不工作现象。
* 在一个特定的地址里把数据读出来,如果发现不等于0x5a,则重新写入0x5a,再读出来
* 判断是不是等于0x5a,如果不相等,则芯片有问题,出错报警提示。
*/
	ucCheckEeprom = read_eeprom(254);	/* 判断AT24C02是否正常 */
	if(ucCheckEeprom != 0x5a)	/* 如果不等于特定内容。则重新写入数据再判断一次 */
	{
		write_eeprom(254, 0x5a);	/* 重新写入标志数据 */
		ucCheckEeprom = read_eeprom(254);	/* 判断AT24C02是否正常 */
		if(ucCheckEeprom != 0x5a)	/* 如果还是不等于特定数字,则芯片不正常 */
		{
			ucEepromError = 1;	/* 表示AT24C02芯片出错报警 */
		}
	}

/* 
* 如何初始化EEPROM数据的方法。在使用EEPROM时,这一步初始化很关键!
* 第一次上电时,我们从EEPROM读取出来的数据有可能超出了范围,可能是ff。
* 这个时候我们应该给它填入一个初始化的数据,这一步千万别漏了。另外,
* 由于int类型数据占用2个字节,所以以下4个数据挨着的地址是0,2,4,6.
*/
	uiSetData1 = read_eeprom_int(0);	/*读取uiSetData1,内部占用2个字节地址*/
	if(uiSetData1 > 9999)	/*不在范围内*/
	{
		uiSetData1 = 0;	/*填入一个初始化数据*/
		write_eeprom_int(0, uiSetData1);	/*存入uiSetData1,内部占用2个字节地址*/
	}
	uiSetData2 = read_eeprom_int(2);	/*读取uiSetData2,内部占用2个字节地址*/
	if(uiSetData2 > 9999)	/*不在范围内*/
	{
		uiSetData2 = 0;	/*填入一个初始化数据*/
		write_eeprom_int(2, uiSetData2);	/*存入uiSetData2,内部占用2个字节地址*/
	}
	uiSetData3 = read_eeprom_int(4);	/*读取uiSetData3,内部占用2个字节地址*/
	if(uiSetData3 > 9999)	/*不在范围内*/
	{
		uiSetData3 = 0;	/*填入一个初始化数据*/
		write_eeprom_int(4, uiSetData3);	/*存入uiSetData3,内部占用2个字节地址*/
	}
	uiSetData4 = read_eeprom_int(6);	/*读取uiSetData4,内部占用2个字节地址*/
	if(uiSetData4 > 9999)	/*不在范围内*/
	{
		uiSetData4 = 0;	/*填入一个初始化数据*/
		write_eeprom_int(6, uiSetData4);	/*存入uiSetData4,内部占用2个字节地址*/
	}
}

/**
* @brief  初始化函数
* @param  无
* @retval 初始化单片机
**/
void Init(void)
{
	LED  = 0;
	BEEP = 1;
	Key_Gnd = 0;
	Dig_Hc595_Drive(0x00, 0x00);	/*关闭所有经过另外两个74HC595驱动的LED灯*/
	Init_T0();
}


/**
* @brief  显示数码管字模的驱动函数
* @param  无
* @retval	动态驱动数码管的原理
* 在八位数码管中,在任何一个瞬间,每次只显示其中一位数码管,另外的七个数码管
* 通过设置其公共位com为高电平来关闭显示,只要切换画面的速度足够快,人的视觉就分辨不出来,感觉八个数码管
* 是同时亮的。以下dig_hc595_drive(xx,yy)函数,其中第一个形参xx是驱动数码管段seg的引脚,第二个形参yy是驱动
* 数码管公共位com的引脚。
**/
void Display_Drive(void)
{
	switch(ucDisplayDriveStep)
	{
		case 1:	/*显示第1位*/
			ucDigShowTemp = Dig_Table[ucDigShow1];
			if(ucDigDot1 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xfe);
		break;
		case 2:	/*显示第2位*/
			ucDigShowTemp = Dig_Table[ucDigShow2];
			if(ucDigDot2 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xfd);
		break;
		case 3:	/*显示第3位*/
			ucDigShowTemp = Dig_Table[ucDigShow3];
			if(ucDigDot3 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xfb);
		break;
		case 4:	/*显示第4位*/
			ucDigShowTemp = Dig_Table[ucDigShow4];
			if(ucDigDot4 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xf7);
		break;
		case 5:	/*显示第5位*/
			ucDigShowTemp = Dig_Table[ucDigShow5];
			if(ucDigDot5 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xef);
		break;
		case 6:	/*显示第6位*/
			ucDigShowTemp = Dig_Table[ucDigShow6];
			if(ucDigDot6 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xdf);
		break;
		case 7:	/*显示第7位*/
			ucDigShowTemp = Dig_Table[ucDigShow7];
			if(ucDigDot7 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0xbf);
		break;
		case 8:	/*显示第8位*/
			ucDigShowTemp = Dig_Table[ucDigShow8];
			if(ucDigDot8 == 1)
			{
				ucDigShowTemp = ucDigShowTemp | 0x80;	/*显示小数点*/
			}
			Dig_Hc595_Drive(ucDigShowTemp, 0x7f);
		break;
	}
	ucDisplayDriveStep ++;	/*逐位显示*/
	if(ucDisplayDriveStep > 8)	/*扫描完8个数码管后,重新从第一个开始扫描*/
	{
		ucDisplayDriveStep = 1;
	}
}
/**
* @brief  数码管的595驱动函数
* @param  无
* @retval 
* 如果直接是单片机的IO口引脚驱动的数码管,由于驱动的速度太快,此处应该适当增加一点delay延时或者
* 用计数延时的方式来延时,目的是在八位数码管中切换到每位数码管显示的时候,都能停留一会再切换到其它
* 位的数码管界面,这样可以增加显示的效果。但是,由于是间接经过74HC595驱动数码管的,
* 在单片机驱动74HC595的时候,dig_hc595_drive函数本身内部需要执行很多指令,已经相当于delay延时了,
* 因此这里不再需要加delay延时函数或者计数延时。
**/
void Dig_HC595_Drive(unsigned char ucDigStatusTemp16_09, unsigned char ucDigStatusTemp08_01)
{
	unsigned char i;
	unsigned char ucTempData;
	Dig_Hc595_Sh = 0;
	Dig_Hc595_St = 0;	
	
	ucTempData = ucDigStatusTemp16_09;	/*先送高8位*/
	for(i = 0; i < 8; i ++)
	{
		if(ucTempData >= 0x80)
		{
			Dig_Hc595_Ds = 1;
		}
		else
		{
			Dig_Hc595_Ds = 0;
		}
		/*注意,此处的延时delay_short必须尽可能小,否则动态扫描数码管的速度就不够。*/
		Dig_Hc595_Sh = 0;	/*SH引脚的上升沿把数据送入寄存器*/
		delay_short(1); 
		Dig_Hc595_Sh = 1;
		delay_short(1); 	
			
		ucTempData = ucTempData <<1;
	}
	ucTempData = ucDigStatusTemp08_01;	/*再先送低8位*/
	for(i = 0; i < 8; i ++)
	{
		if(ucTempData >= 0x80)
		{
			Dig_Hc595_Ds = 1;
		}
		else
		{
			Dig_Hc595_Ds = 0;
		}
		Dig_Hc595_Sh = 0;	/*SH引脚的上升沿把数据送入寄存器*/
		delay_short(1); 
		Dig_Hc595_Sh = 1;
		delay_short(1); 	
			
		ucTempData = ucTempData <<1;
	}
	
	Dig_Hc595_St = 0;	/*ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来*/
	delay_short(1);
	Dig_Hc595_St = 1;
	delay_short(1);
	
	Dig_Hc595_Sh = 0;	/*拉低,抗干扰就增强*/
	Dig_Hc595_St = 0;
	Dig_Hc595_Ds = 0;
}
/**
* @brief  显示的窗口菜单服务程序
* @param  无
* @retval 
*凡是人机界面显示,不管是数码管还是液晶屏,都可以把显示的内容分成不同的窗口来显示,
*每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单,用ucWd变量表示。
*局部就是二级菜单,用ucPart来表示。不同的窗口,会有不同的更新显示变量ucWdXUpdate来对应,
*表示整屏全部更新显示。不同的局部,也会有不同的更新显示变量ucWdXPartYUpdate来对应,表示局部更新显示。
**/
void Display_Service(void)	/*显示的窗口菜单服务程序*/
{
		switch(ucWd)
		{
			case 1:	/*显示P--1窗口的数据*/
				if(ucWd1Update == 1)	/*窗口1要全部更新显示*/
				{
					ucWd1Update = 0;	/*及时清零标志,避免一直进来扫描*/
					ucDigShow8 = 12;	/*第8位数码管显示P*/
					ucDigShow7 = 11;	/*第7位数码管显示-*/
					ucDigShow6 = 1;		/*第6位数码管显示1*/
					ucDigShow5 = 10;	/*第5位数码管不显示*/
/* 
* 此处为什么要多加4个中间过渡变量ucTemp?是因为uiSetData1分解数据的时候
* 需要进行除法和求余数的运算,就会用到好多条指令,就会耗掉一点时间,类似延时
* 了一会。我们的定时器每隔一段时间都会产生中断,然后在中断里驱动数码管显示,
* 当uiSetData1还没完全分解出4位有效数据时,这个时候来的定时中断,就有可能导致
* 显示的数据瞬间产生不完整,影响显示效果。因此,为了把需要显示的数据过渡最快,
* 所以采取了先分解,再过渡显示的方法。
*/
					/*先分解数据*/
					ucTemp4 = uiSetData1 / 1000;
					ucTemp3 = uiSetData1 % 1000 / 100;
					ucTemp2 = uiSetData1 % 100 / 10;
					ucTemp1 = uiSetData1 %10;
					/*再过渡需要显示的数据到缓冲变量里,让过渡的时间越短越好*/
					/*就是在这里略作修改,把高位为0的去掉不显示。*/
					if(uiSetData1 < 1000)
					{
						ucDigShow4 = 10;
					}
					else
					{
						ucDigShow4 = ucTemp4;	/*第4位数码管要显示的内容*/						
					}
					if(uiSetData1 < 100)
					{
						ucDigShow3 = 10;
					}
					else
					{
						ucDigShow3 = ucTemp3;	/*第3位数码管要显示的内容*/						
					}
					if(uiSetData1 < 10)
					{
						ucDigShow2 = 10;
					}
					else
					{
						ucDigShow2 = ucTemp2;	/*第2位数码管要显示的内容*/						
					}
					ucDigShow1 = ucTemp1;	/*第1位数码管要显示的内容*/					
				}
			break;
				
			case 2:	/*显示P--2窗口的数据*/
				if(ucWd2Update == 1)	/*窗口2要全部更新显示*/
				{
					ucWd2Update = 0;	/*及时清零标志,避免一直进来扫描*/
					ucDigShow8 = 12;	/*第8位数码管显示P*/
					ucDigShow7 = 11;	/*第7位数码管显示-*/
					ucDigShow6 = 2;		/*第6位数码管显示2*/
					ucDigShow5 = 10;	/*第5位数码管不显示*/
					/*先分解数据*/
					ucTemp4 = uiSetData2 / 1000;
					ucTemp3 = uiSetData2 % 1000 / 100;
					ucTemp2 = uiSetData2 % 100 / 10;
					ucTemp1 = uiSetData2 %10;
					if(uiSetData2 < 1000)
					{
						ucDigShow4 = 10;
					}
					else
					{
						ucDigShow4 = ucTemp4;	/*第4位数码管要显示的内容*/						
					}
					if(uiSetData2 < 100)
					{
						ucDigShow3 = 10;
					}
					else
					{
						ucDigShow3 = ucTemp3;	/*第3位数码管要显示的内容*/						
					}
					if(uiSetData2 < 10)
					{
						ucDigShow2 = 10;
					}
					else
					{
						ucDigShow2 = ucTemp2;	/*第2位数码管要显示的内容*/						
					}
					ucDigShow1 = ucTemp1;	/*第1位数码管要显示的内容*/									
				}
			break;	

			case 3:	/*显示P--3窗口的数据*/
				if(ucWd3Update == 1)	/*窗口3要全部更新显示*/
				{
					ucWd3Update = 0;	/*及时清零标志,避免一直进来扫描*/
					ucDigShow8 = 12;	/*第8位数码管显示P*/
					ucDigShow7 = 11;	/*第7位数码管显示-*/
					ucDigShow6 = 3;		/*第6位数码管显示3*/
					ucDigShow5 = 10;	/*第5位数码管不显示*/
					/*先分解数据*/
					ucTemp4 = uiSetData3 / 1000;
					ucTemp3 = uiSetData3 % 1000 / 100;
					ucTemp2 = uiSetData3 % 100 / 10;
					ucTemp1 = uiSetData3 %10;
					if(uiSetData3 < 1000)
					{
						ucDigShow4 = 10;
					}
					else
					{
						ucDigShow4 = ucTemp4;	/*第4位数码管要显示的内容*/						
					}
					if(uiSetData3 < 100)
					{
						ucDigShow3 = 10;
					}
					else
					{
						ucDigShow3 = ucTemp3;	/*第3位数码管要显示的内容*/						
					}
					if(uiSetData3 < 10)
					{
						ucDigShow2 = 10;
					}
					else
					{
						ucDigShow2 = ucTemp2;	/*第2位数码管要显示的内容*/						
					}
					ucDigShow1 = ucTemp1;	/*第1位数码管要显示的内容*/							
				}
			break;			

			case 4:	/*显示P--4窗口的数据*/
				if(ucWd4Update == 1)	/*窗口4要全部更新显示*/
				{
					ucWd4Update = 0;	/*及时清零标志,避免一直进来扫描*/
					ucDigShow8 = 12;	/*第8位数码管显示P*/
					ucDigShow7 = 11;	/*第7位数码管显示-*/
					ucDigShow6 = 4;		/*第6位数码管显示4*/
					ucDigShow5 = 10;	/*第5位数码管不显示*/
					/*先分解数据*/
					ucTemp4 = uiSetData4 / 1000;
					ucTemp3 = uiSetData4 % 1000 / 100;
					ucTemp2 = uiSetData4 % 100 / 10;
					ucTemp1 = uiSetData4 %10;
					if(uiSetData4 < 1000)
					{
						ucDigShow4 = 10;
					}
					else
					{
						ucDigShow4 = ucTemp4;	/*第4位数码管要显示的内容*/						
					}
					if(uiSetData4 < 100)
					{
						ucDigShow3 = 10;
					}
					else
					{
						ucDigShow3 = ucTemp3;	/*第3位数码管要显示的内容*/						
					}
					if(uiSetData4 < 10)
					{
						ucDigShow2 = 10;
					}
					else
					{
						ucDigShow2 = ucTemp2;	/*第2位数码管要显示的内容*/						
					}
					ucDigShow1 = ucTemp1;	/*第1位数码管要显示的内容*/							
				}
			break;					
		}
}

/**
* @brief  扫描按键
* @param  无
* @retval 放在定时中断里
**/
void key_scan(void)
{
	if(Key_S1 == 1)	/*IO是高电平,说明按键没有被按下,这时要及时清零一些标志位*/	
	{
		ucKeyLock1 = 0;	/*按键自锁标志清零*/
		uiKeyTimeCnt1 = 0;	/*按键去抖动延时计数器清零*/
	}
	else if(ucKeyLock1 == 0)	/*有按键按下,且是第一次被按下*/
	{
		uiKeyTimeCnt1 ++;	/*累加定时中断次数*/
		if(uiKeyTimeCnt1 > const_key_time1)
		{
			uiKeyTimeCnt1 = 0;
			ucKeyLock1 = 1;
			ucKeySec = 1;	/*触发1号键*/
		}
	}

	if(Key_S2 == 1)	/*IO是高电平,说明按键没有被按下,这时要及时清零一些标志位*/	
	{
		ucKeyLock2 = 0;	/*按键自锁标志清零*/
		uiKeyTimeCnt2 = 0;	/*按键去抖动延时计数器清零*/
	}
	else if(ucKeyLock2 == 0)	/*有按键按下,且是第一次被按下*/
	{
		uiKeyTimeCnt2 ++;	/*累加定时中断次数*/
		if(uiKeyTimeCnt2 > const_key_time2)
		{
			uiKeyTimeCnt2 = 0;
			ucKeyLock2 = 1;
			ucKeySec = 2;	/*触发2号键*/
		}
	}

	if(Key_S3 == 1)	/*IO是高电平,说明按键没有被按下,这时要及时清零一些标志位*/	
	{
		ucKeyLock3 = 0;	/*按键自锁标志清零*/
		uiKeyTimeCnt3 = 0;	/*按键去抖动延时计数器清零*/
	}
	else if(ucKeyLock3 == 0)	/*有按键按下,且是第一次被按下*/
	{
		uiKeyTimeCnt3 ++;	/*累加定时中断次数*/
		if(uiKeyTimeCnt3 > const_key_time3)
		{
			uiKeyTimeCnt3 = 0;
			ucKeyLock3 = 1;
			ucKeySec = 3;	/*触发3号键*/
		}
	}	
}

/**
* @brief  按键服务的应用程序
* @param  无
* @retval 无
**/
void key_service(void)
{
	switch(ucKeySec)	/*按键服务状态切换*/
	{
		case 1:	/*加按键*/
			switch(ucWd)	/*在不同的窗口下,设置不同的参数*/
			{
				case 1:
					uiSetData1 ++;
					if(uiSetData1 > 9999)
					{
						uiSetData1 = 9999;
					}
					write_eeprom_int(0, uiSetData1);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd1Update = 1;	/*窗口1更新显示*/
					break;
				case 2:
					uiSetData2 ++;
					if(uiSetData2 > 9999)
					{
						uiSetData2 = 9999;
					}
					write_eeprom_int(2, uiSetData2);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd2Update = 1;	/*窗口1更新显示*/
					break;
				case 3:
					uiSetData3 ++;
					if(uiSetData3 > 9999)
					{
						uiSetData3 = 9999;
					}
					write_eeprom_int(4, uiSetData3);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd3Update = 1;	/*窗口1更新显示*/
					break;
				case 4:
					uiSetData4 ++;
					if(uiSetData4 > 9999)
					{
						uiSetData4 = 9999;
					}
					write_eeprom_int(6, uiSetData4);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd4Update = 1;	/*窗口1更新显示*/
					break;				
			}
			ucVoiceLock = 1;
			uiVoiceCnt = const_voice_short;
			ucVoiceLock = 0;
			ucKeySec = 0;
			break;

		case 2:	/*减按键*/
			switch(ucWd)	/*在不同的窗口下,设置不同的参数*/
			{
				case 1:
					uiSetData1 --;
					if(uiSetData1 > 9999)
					{
						uiSetData1 = 0;
					}
					write_eeprom_int(0, uiSetData1);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd1Update = 1;	/*窗口1更新显示*/
					break;
				case 2:
					uiSetData2 --;
					if(uiSetData2 > 9999)
					{
						uiSetData2 = 0;
					}
					write_eeprom_int(2, uiSetData2);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd2Update = 1;	/*窗口1更新显示*/
					break;
				case 3:
					uiSetData3 --;
					if(uiSetData3 > 9999)
					{
						uiSetData3 = 0;
					}
					write_eeprom_int(4, uiSetData3);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd3Update = 1;	/*窗口1更新显示*/
					break;
				case 4:
					uiSetData4 --;
					if(uiSetData4 > 9999)
					{
						uiSetData4 = 0;
					}
					write_eeprom_int(6, uiSetData4);	/*存入EEPROM 由于内部有延时函数,所以此处会引起数码管闪烁*/
					ucWd4Update = 1;	/*窗口1更新显示*/
					break;				
			}
			ucVoiceLock = 1;
			uiVoiceCnt = const_voice_short;
			ucVoiceLock = 0;
			ucKeySec = 0;		
			break;
		
		case 3:	/*切换窗口按键*/
			ucWd ++;	/*切换窗口*/
			if(ucWd > 4)
			{
				ucWd = 1;
			}
			switch(ucWd)
			{
				case 1:
					ucWd1Update = 1;
					break;
				case 2:
					ucWd2Update = 1;
					break;
				case 3:
					ucWd3Update = 1;
					break;
				case 4:
					ucWd4Update = 1;
					break;
			}
			ucVoiceLock = 1;
			uiVoiceCnt = const_voice_short;
			ucVoiceLock = 0;	
			ucKeySec = 0;	
			break;	
	
	}
}


/**
* @brief  定时器0中断函数
* @param  无
* @retval 无
**/
void ISR_T0(void)	interrupt 1
{
	TF0 = 0;  /*清除中断标志*/
	TR0 = 0; /*关中断*/
	/* 
	* 此处多增加一个原子锁,作为中断与主函数共享数据的保护
	*/
	if(ucVoiceLock == 0)	/*原子锁判断*/
	{
		if(uiVoiceCnt != 0)
		{
			uiVoiceCnt --;
			BEEP = 0;
		}
		else
		{
			;
			BEEP = 1;
		}		
	}

	if(ucDelayTimerLock == 0)
	{
		if(uiDelayTimer > 0)
		{
			uiDelayTimer --;	/* 一气呵成的定时器延时方式的计时器 */
		}
	}

	if(ucEepromError == 1)	/* EEPROM出错 */
	{
		if(ucEepromLock == 0)
		{
			uiEepromCnt ++;	/* 间歇性蜂鸣器报警的计时器 */
		}
	}
	key_scan();
	Display_Drive();	/*数码管字模的驱动函数*/
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
  	TR0 = 1; /*开中断*/	
}


/*————————————主函数————————————*/
/**
* @brief  主函数
* @param  无
* @retval 实现LED灯闪烁
**/
void main()
{
	/*单片机初始化*/
	Init();
	/*延时,延时时间一般是0.3秒到2秒之间,等待外围芯片和模块上电稳定*/
	Delay_Long(100);
	/*单片机外围初始化*/	
	Init_Peripheral();
	while(1)
	{
		key_service();	/*按键服务的应用程序*/   
		Display_Service();	/*显示的窗口菜单服务程序*/  
		eeprom_alarm_service();	/* EEPROM出错报警 */      
	}
}

三、仿真实现

若24C02出现短路或虚焊等现象,则蜂鸣器报警。

51单片机实现操作AT24C02时,利用“一气呵成的定时器延时”改善数码管的闪烁现象

原文地址:https://www.cnblogs.com/zhq426611/p/13460569.html