devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

（51单片机）第八章-I2C总线AT24C02芯片应用

作者：Monodyee | 2024-04-20 07:01:56

赞

踩

（51单片机）第八章-I2C总线AT24C02芯片应用

8.1 I2C总线概述

1. I2C总线介绍

        I2C总线(Inter IC Bus)由PHILIPS 公司推出，是近年来微电子通信控制领域广泛采用的一种新型总线标准，它是同步通信的一种特殊形式，具有接口线少、控制简单、器件封装形式小、通信速率较高等优点。在主从通信中，可以有多个I2C总线器件同时接到I2C总线上，所有与I2C兼容的器件都具有标准的接口，通过地址来识别通信对象，使它们可以经由I2C总线互相直接通信。

        I2C总线由数据线 SDA 和时钟线 SCL两条线构成通信线路，既可发送数据，也可接收数据。在 CPU与被控IC之间、IC与IC之间都可进行双向传送，最高传送速率为400kbps，各种被控器件均并联在总线上，但每个器件都有唯一的地址。在信息传输过程中，I2C总线上并联的每一个器件既是被控器(或主控器)，又是发送器(或接收器)，这取决于它所要完成的功能。CPU 发出的控制信号分为地址码和数据码两部分：地址码用来选址，即接通需要控制的电路；数据码是通信的内容，这样各IC控制电路虽然挂在同一条总线上，却彼此独立。

2. I2C总线硬件结构图

        下图为I2C总线系统的硬件结构图，其中，SCL是时钟线，SDA是数据线。总线上各器件都采用漏极开路结构与总线相连，因此SCL和SDA 均需接上拉电阻，总线在空闲状态下均保持高电平，连到总线上的任一器件输出的低电平，都将使总线的信号变低，即各器件的 SDA 及 SCL 都是线“与”关系。

        I2C总线支持多主和主从两种工作方式，通常为主从工作方式。在主从工作方式中，系统中只有一个主器件(单片机)，其他器件都是具有I2C总线的外围从器件。在主从工作方式中，主器件启动数据的发送(发出启动信号)，产生时钟信号，发出停止信号。

 3. I2C总线通信格式

        下图为I2C总线上进行一次数据传输的通信格式：

4. 数据位的有效性规定

        I2C总线进行数据传输时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有时钟信号为低电平期间，数据信号的高电平或低电平才允许变化：

5. 发送启动（始）信号

        在利用I2C总线进行一次数据传输时，首先由主机发出启动信号，启动I2C总线，在SCL为高电平期间，SDA出现下降沿（原书写错）为启动信号，此时，具有I2C总线接口的从器件会检测到该信号，启动时序如下图所示：

 6. 发送寻址信号

        主机发送启动信号后，再发出寻址信号。器件地址有7位和10位两种，这里只介绍7位地址寻址方式。寻址字节的位定义如下图所示，寻址信号由一个字节构成，高7位为地址位，最低位为方向位，用以表明主机与从器件的数据传送方向。方向位为0，表明主机接下来对从器件进行写操作；方向位为1，表明主机接下来对从器件进行读操作：

        主机发送地址时，总线上的每个从机都将这7位地址码与自己的地址进行比较，如果相同，则认为自己正被主机寻址，根据 R/W位将自己确定为发送器或接收器。

        从机的地址由固定部分和可编程部分组成。在一个系统中可能希望接入多个相同的从机，从机地址中可编程部分决定了可接入总线该类器件的最大数目。如一个从机的7位寻址位有4位是固定位，3位是可编程位，这时仅能寻址8个同样的器件，即可以有8个同样的器件接入到该IC总线系统中。

  7. 应答信号

        I2C总线协议规定，每传送一个字节数据(含地址及命令字)后，都要有一个应信号，以确定数据传送是否被对方收到。应答信号由接收设备产生，在SCL信号为高电平期间，接收设备将 SDA 拉为低电平，表示数据传输正确，产生应答，时序图如下图所示。

8. 数据传输

        主机发送寻址信号并得到从器件应答后，便可以进行数据传输，每次一个字节，但每次都应在得到应答信号后再进行下一字节的传送。

9. 非应答信号

        当主机为接收设备时，主机对最后一个字节不应答，以向发送设备表示数据传送结束。

10. 发送停止信号

        在全部数据传送完毕后，主机发送停止信号，记在SCL为高电平期间，SDA上产生一上升沿信号，停止时序图如下图所示：

8.2 单片机模拟I2C

        目前市场上很多单片机都已经具有硬件I2C总线控制单元，这类单片机在工作时，总线状态由硬件监测，无须用户介入，操作非常方便。但是还有许多单片机并不具有I2C总线接口，如51单片机，但可以在单片机应用系统中通过软件模拟I2C总线的工作时序，在使用时，只需正确调用各个函数就能方便地扩展I2C总线接口器件。在总线的一次数据传送过程中，可以有以下几种组合方式：

        (1)主机向从机发送数据，数据传送方向在整个传送过程中不变；

        (2)主机在第一个字节后，立即从从机读数据；

        (3)在传送过程中，当需要改变传送方向时，需将起始信号和从机地址各重复产生一次，而两次读/写方向位正好相反。

        为了保证数据传送的可靠性，标准I2C总线的数据传送有严格的时序要求。I2C总线的起始信号、终止信号、应答或发送“0”、非应答或发送“1”的模拟时序如下图所示。

        单片机在模拟I2C总线通信时，需写出如下几个关键部分的程序：总线初始化、启动信应答信号、停止信号、写一个字节、读一个字节。下面分别给出具体函数的写法以供参考，在阅读代码时请参考前面相关部分的文字描述及时序图。

1. 总线初始化

2. 启动信号

3. 应答信号

4. 停止信号

5. 写一个字节

6. 读一个字节

8.3 E2PROM AT24C02与单片机的通信实例

        具有I2C总线接口的E2PROM 有多个厂家的多种类型产品。在此仅介绍ATMEL公司生产的 AT24C系列E-PROM，主要型号有AT24C01/02104/08/16等，其对应的存储容量分别头128x8/256x8/512x8/1024x8/2048x8。采用这类芯片可解决掉电数据保存问题，可对所存数据保存100年，并可多次擦写，擦写次数可达10万次以上。在一些应用系统设计中，有时需要对工作数据进行掉电保护，如电子式电能表等智能化产品。若采用普通存储器，在掉电时需要备用电池供电，并需要在硬件上增加掉电检测电路，但存在电池不可靠及扩展存储芯片占用单片机过多口线的缺点。采用具有I2C总线接口的串行 E2PROM 器件可很好地解决掉电数据保存问题，且硬件电路简单。下面以AT24C02芯片为例，介绍具有I2C总线接口的 E2PROM 的具体应用。

1. AT24C02引脚配置与引脚功能

        AT24C02 芯片的常用封装形式有直插(DIP8)式和贴片(SO-8)式两种，无论直插式还是贴片式，其引脚功能与序号都一样：

 

        各引脚功能如下:

                1，2，3(A0、A1、A2)-可编程地址输入端。

                4(GND)——电源地。

                5(SDA)——串行数据输入/输出端。

                6(SCL)——串行时钟输入端。

                7(WP)——写保护输入端，用于硬件数据保护。当其为低电平时，可以对整个存储器进行正常的读/写操作;当其为高电平时，存储器具有写保护功能，但读操作不受影响。

                8(Vcc)——电源正端。

2. 存储结构与寻址

        AT24C02的存储容量为2KB，内部分成32页，每页8B，共256B，操作时有两种寻址方式：芯片寻址和片内子地址寻址。

(1)芯片寻址。

        AT24C02的芯片地址为1010，其地址控制字格式为1010A2A1A0 R/w。其中 A2，A1，A0为可编程地址选择位。A2，A1，A0引脚接高、低电平后得到确定的三位编码，与1010形成7位编码，即为该器件的地址码。R/w为芯片读写控制位，该位为0，表示对芯片进行写操作；该位为1，表示对芯片进行读操作。

(2)片内子地址寻址。

        芯片寻址可对内部256B中的任一个进行读/写操作，其寻址范围为00~FF，共256个寻址单元。

 3. 读/写操作时序

        串行 E2PROM 一般有两种写入方式：一种是字节写入方式，另一种是页写入方式。页写入方式允许在一个写周期内(10ms左右)对一个字节到一页的若干字节进行编程写入，AT24C02的页面大小为8B。采用页写方式可提高写入效率，但也容易发生事故。AT24C系列片内地址在接收到每一个数据字节后自动加1,故装载一页以内数据字节时,只需输入首地址,如果写到此页的最后一个字节，主器件继续发送数据，数据将重新从该页的首地址写入，进而造成原来的数据丢失，这就是页地址空间的“上卷”现象。

        解决“上卷”的方法是:在第8个数据后将地址强制加1，或是将下一页的首地址重新赋给寄存器。

(1) 字节写入方式

        单片机在一次数据帧中只访问E2PROM一个单元。该方式下，单片机先发送启动信号，然后送一个字节的控制字，再送一个字节的存储器单元子地址，上述几个字节都得到 E2PROM 响应后,再发送8位数据,最后发送1位停止信号。发送格式如下图所示。

(2) 页写入方式

        单片机在一个数据写周期内可以连续访问1页(8个)E2PROM存储单元。在该方式中，单片机先发送启动信号，接着送一个字节的控制字，再送1个字节的存储器起始单元地址，上述几个字节都得到EPROM 应答后就可以发送最多1页的数据，并顺序存放在以指定起始地址开始的相继单元中，最后以停止信号结束。页写入帧格式如下图所示。

(3) 指定地址读操作

        读指定地址单元的数据。单片机在启动信号后先发送含有片选地址的写操作控制字，E2PROM 应答后再发送1个(2KB以内的EPROM)字节的指定单元的地址，E2PROM 应答后再发送1个含有片选地址的读操作控制字，此时如果EPROM 做出应答，被访问单元的数据就会按SCL信号同步出现在串行数据/地址线SDA上。这种读操作的数据帧格式如下图所示。

(4)指定地址连续读

        此种方式的读地址控制与前面指定地址读相同。单片机接收到每个字节数据后应做出应答，只要E2PROM 检测到应信号，其内部的地址寄存器就自动加1指向下一单元，并顺序将指向的单元的数据送到SDA串行数据线上。当需要结束读操作时单片机接收到数据后在需要应答的时刻发送一个非应答信号，接着再发送一个停止信号即可这种读操作的数据帧格式如下图所示。

4. TX-1C实验板上AT24C02连接图

        TX-1C实验板上 AT24C02与单片机连接如下图所示，其中A0、A1、A2与 WP 都接地，SDA 接单片机 P2.0脚，SCL接单片机 P2.1脚，SDA与SCL分别与Vcc之间接10kΩ上拉电阻，因为 AT24C02总线内部是漏极开路形式，不接上拉电阻无法确定总线空闲时的电平状态。

        

【例8.3.1】

        用C语言编写程序，在TX-1℃实验板上实现如下功能:利用定时器产生个0~99 秒变化的秒表，并且显示在数码管上，每过一秒将这个变化的数写入板上AT24C02内部。当关闭实验板电源，并再次打开实验板电源时，单片机先从AT24C02中将原来写入的数读取出来，接着此数继续变化并显示在数码管上。

        通过本实验可以看到，若向AT24C02中成功写入，并且成功读取则数码管上显示的数会接着关闭实验板时的数继续显示，否则有可能显示乱码。

        注：为加快显示本人的程序不是1s一变

  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4.  
  5. bit write=0; //写AT24C02的标志
  6.  
  7. sbit SDA=P2^0; //声明数据线端口
  8. sbit SCL=P2^1; //声明时钟线端口
  9. sbit dula=P2^6; //声明U1锁存器的锁存端
  10. sbit wela=P2^7; //声明U2锁存器的锁存端
  11. sbit led1=P1^0; //第一位发光二极管（0亮1灭）
  12. sbit beep=P2^3;	//声明蜂鸣器引脚（0响1灭）
  13.  
  14. uchar code dula_table[]={
  15. 	0x3f,0x06,0x5b,0x4f, //0,1,2,3
  16. 	0x66,0x6d,0x7d,0x07, //4,5,6,7
  17. 	0x7f,0x6f,0x77,0x7c, //8,9,10,11
  18. 	0x39,0x5e,0x79,0x71  //12,13,14,15
  19. };
  20.  
  21. uchar code wela_table[]=
  22. {
  23. 	  0xdf,0xef,0xf7,0xfb,0xfd,0xfe	//从右向左数第一到六位
  24. };
  25.  
  26. uchar sec,tcnt,ms100,ms10;
  27. uint wei;
  28.  
  29. void main()
  30. {
  31. 	void init(); // 总线初始化
  32. 	void init_wedu(); //数码管显示和定时器初始化操作
  33. 	void write_add(uchar address,uchar Data);
  34. 	void display();
  35.  
  36. 	init();
  37. 	init_wedu();
  38. 	while(1)
  39. 	{
  40. 		display();
  41. 		if(write==1)
  42. 		{
  43. 			write=0;
  44. 			ms100=sec/10;
  45. 			ms10=sec%10;
  46. 			write_add(2,sec);
  47. 		}
  48. 	}
  49. 		
  50. }
  51.  
  52. void delay() //微秒级延时函数，该延时函数大约延时4~5微秒，用于操作I2C总线时用
  53. {
  54. 	;;
  55. }
  56.  
  57. void delayxms(uint xms)
  58. {
  59. 	uint x,y;
  60. 	for(x=xms;x>0;x--)
  61. 		for(y=124;y>0;y--);	
  62. }    
  63.  
  64.  
  65. void init() // 总线初始化
  66. {
  67. 	void delay();
  68.  
  69. 	//将总线都拉高以释放总线
  70. 	SCL=1; //时钟线拉高
  71. 	delay();
  72. 	SDA=1; //数据线拉高
  73. 	delay();
  74. }
  75.  
  76. void init_wedu() //数码管显示和定时器初始化操作
  77. {
  78. 	uchar read_add(uchar address);
  79.  
  80. 	dula=0; //初始化，段选置0
  81. 	wela=0; //初始化，片选置0
  82.  
  83. 	led1=1;	//初始化，二极管灯灭
  84. 	beep=1;	//初始化，蜂鸣器不响
  85.  
  86. 	TMOD=0x10;//设置定时器0和1的工作方式为1（0001 0001）
  87. 	TH1=(65536-4608)/256; //装初值
  88. 	TL1=(65536-4608)%256; //装初值
  89. 	EA=1;//打开总中断
  90. 	ET1=1;//打开定时器1中断
  91. 	TR1=1;//启动定时器1
  92.  
  93. 	sec=read_add(2);
  94. 	if(sec>100) sec=0; //防止首次读取出错误数据
  95. 	ms100=sec/10;
  96. 	ms10=sec%10;
  97. 	display();
  98. }
  99.  
  100. void start() //启动信号
  101. {
  102. 	SDA=1; //数据线拉高
  103. 	delay();
  104. 	SCL=1; //时钟线拉高
  105. 	delay();
  106. 	SDA=0; //数据线拉低，在SCL高电平期间产生下降沿启动信号
  107. 	delay();	
  108. }
  109.  
  110. void respond() //应答信号
  111. {
  112. 	void delay();
  113.  
  114. 	uchar i=0;
  115. 	SCL=1; //时钟线拉高
  116. 	delay();
  117. 	while((SDA==1)&&(i<255)) i++; 
  118. 	//若一段时间主器件没有收到从器件的应答则默认
  119. 	//从器件已经收到数据不再等待应答信号
  120. 	//若不加这个延时退出，一旦从器件没有发送应答信号
  121. 	//程序将永远停留在此处
  122. 	SCL=0; //SCL高电平期间，SDA被从设备置低电平表示应答
  123. 	delay();
  124. }
  125.  
  126. void stop() //停止信号
  127. {
  128. 	void delay();
  129.  
  130. 	//SCL高电平期间，SDA一个上升沿产生停止信号
  131. 	SDA=0;
  132. 	delay();
  133. 	SCL=1;
  134. 	delay();
  135. 	SDA=1;
  136. 	delay();
  137. }
  138.  
  139. void write_byte(uchar Data) //写一个字节
  140. {
  141. 	void delay();
  142.  
  143. 	uchar i,temp;
  144. 	temp=Data;
  145. 	for(i=0;i<8;i++)
  146. 	{
  147. 		temp=temp<<1; 
  148. 		//串行发送字节是，需要将该字节的8位逐位发送
  149. 		//temp=temp<<1表示将temp左移一位，最高位将一如PSW寄存器的CY位中
  150. 		//然后将CY赋给SDA进而在SCL的控制下发送出去
  151. 		SCL=0;
  152. 		delay();
  153. 		SDA=CY;
  154. 		delay();
  155. 		SCL=1;
  156. 		delay();
  157. 	}
  158. 	SCL=0;
  159. 	delay();
  160. 	SDA=1;
  161. 	delay();
  162. }
  163.  
  164. uchar read_byte() //读一个字节
  165. {
  166. 	void delay();
  167.  
  168. 	uchar i,k; //定义的临时变量k
  169. 	SCL=0;
  170. 	delay();
  171. 	SDA=1;
  172. 	for(i=0;i<8;i++)
  173. 	{
  174. 		//串行接收字节时需要将8位逐位接收，再组合成一个字节
  175. 		//k左移一位后与SDA进行“或”运算
  176. 		//依次把8个独立的位放入一个字节中完成接收
  177. 		SCL=1;
  178. 		delay();
  179. 		k=(k<<1)|SDA;
  180. 		SCL=0;
  181. 		delay();
  182. 	}
  183. 	return k;
  184. }
  185.  
  186. void write_add(uchar address,uchar Data)
  187. {
  188. 	void start(); //启动信号
  189. 	void write_byte(uchar Data); //写一个信号
  190. 	void respond(); //应答信号
  191. 	void stop(); //停止信号
  192.  
  193. 	start();
  194. 	write_byte(0xa0);
  195. 	respond();
  196. 	write_byte(address);
  197. 	respond();
  198. 	write_byte(Data);
  199. 	respond();
  200. 	stop();
  201. }
  202.  
  203. uchar read_add(uchar address)
  204. {
  205. 	void start(); //启动信号
  206. 	void write_byte(uchar Data); //写一个信号
  207. 	uchar read_byte(); //读一个字节
  208. 	void respond(); //应答信号
  209. 	void stop(); //停止信号
  210.  
  211. 	uchar Data;
  212.  
  213. 	start();
  214. 	write_byte(0xa0);
  215. 	respond();
  216. 	write_byte(address); //写入芯片地址，最末位表示方向：0
  217. 	respond();
  218.  
  219. 	start();
  220. 	write_byte(0xa1); //读取芯片地址，最末位表示方向：1
  221. 	respond();
  222. 	Data=read_byte();
  223. 	stop();
  224. 	return Data;
  225. }
  226.  
  227. void display()
  228. {
  229. 	void wedu(uchar dula_num,uchar wela_num);
  230. 	for(wei=0;wei<2;wei++)
  231. 	{
  232. 		switch(wei)
  233. 		{
  234. 			case 0: wedu(ms10,wei);break;
  235. 			case 1: wedu(ms100,wei);break;
  236. 		}	
  237. 	}
  238. }
  239.  
  240.  
  241. void wedu(uchar dula_num,uchar wela_num)
  242. {
  243. 	wela=1; //打开U2锁存端
  244. 	P0=wela_table[wela_num]; //送入U2锁存端
  245. 	wela=0; //关闭U2锁存端
  246. 	P0=0xc0; //消影，防止P0残留电位信号干扰段选
  247. 	dula=1; //打开U1锁存端
  248. 	P0=dula_table[dula_num]; //送入段选信号
  249. 	dula=0; //关闭U1锁存端
  250. 	P0=0xff; //消影，防止P0残留电位信号干扰片选
  251. 	delayxms(1);
  252. }
  253.  
  254. void T1_time() interrupt 3 //中断程序
  255. {
  256. 	TH1=(65536-4608)/256; //装初值
  257. 	TL1=(65536-4608)%256; //装初值
  258. 	tcnt++;
  259. 	if(tcnt==20)
  260. 	{
  261. 		led1=~led1;
  262. 		beep=~beep;
  263. 		tcnt=0;
  264. 		sec++;
  265. 		write=1; //1s写一次AT24C02
  266. 		if(sec==100) sec=0; //定时100s再从零开始计时
  267. 	}
  268. }

 一个尝试：

结合（51单片机）第三章-数码管显示原理及应用实现-中断_单片机复位后数码管显示机-CSDN博客

中的一段程序加以改进，但是仍然存在问题：主程序while(1)里面写入语句的用时比较长，没运行完定时中断再次触发，故每次write_add(5,s10);这段语句都无法正常执行——

  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4.  
  5. bit write=0; //写AT24C02的标志
  6.  
  7. sbit SDA=P2^0; //声明数据线端口
  8. sbit SCL=P2^1; //声明时钟线端口
  9. sbit dula=P2^6; //声明U1锁存器的锁存端
  10. sbit wela=P2^7; //声明U2锁存器的锁存端
  11. sbit led1=P1^0; //第一位发光二极管（0亮1灭）
  12. sbit beep=P2^3;	//声明蜂鸣器引脚（0响1灭）
  13.  
  14. uchar code dula_table[]={
  15. 	0x3f,0x06,0x5b,0x4f, //0,1,2,3
  16. 	0x66,0x6d,0x7d,0x07, //4,5,6,7
  17. 	0x7f,0x6f,0x77,0x7c, //8,9,10,11
  18. 	0x39,0x5e,0x79,0x71  //12,13,14,15
  19. };
  20.  
  21. uchar code wela_table[]=
  22. {
  23. 	  0xdf,0xef,0xf7,0xfb,0xfd,0xfe	//从右向左数第一到六位
  24. };
  25.  
  26. uchar dula_num,wela_num,num,wei;
  27. uchar min10,min,s10,s,ms100,ms10;
  28.  
  29. void main()
  30. {
  31. 	void init(); // 总线初始化
  32. 	void init_wedu(); //数码管显示和定时器初始化操作
  33. 	void write_add(uchar address,uchar Data);
  34. 	void display();
  35.  
  36. 	init();
  37. 	init_wedu();
  38. 	while(1)
  39. 	{
  40. 		display();
  41. 		if(write==1)
  42. 		{
  43. 			write=0;
  44. 			write_add(2,ms10);
  45. 			write_add(3,ms100);
  46. 			write_add(4,s);
  47. 			write_add(5,s10);
  48. 			write_add(6,min);
  49. 			write_add(7,min10);
  50. 		}
  51. 	}
  52. 		
  53. }
  54.  
  55. void delay() //微秒级延时函数，该延时函数大约延时4~5微秒，用于操作I2C总线时用
  56. {
  57. 	;;
  58. }
  59.  
  60. void delayxms(uint xms)	//为显示稳定y的初值在本程序中有所调整
  61. {
  62. 	uint x,y;
  63. 	for(x=xms;x>0;x--)
  64. 		for(y=62;y>0;y--);	
  65. }    
  66.  
  67.  
  68. void init() // 总线初始化
  69. {
  70. 	void delay();
  71.  
  72. 	//将总线都拉高以释放总线
  73. 	SCL=1; //时钟线拉高
  74. 	delay();
  75. 	SDA=1; //数据线拉高
  76. 	delay();
  77. }
  78.  
  79. void init_wedu() //数码管显示和定时器初始化操作
  80. {
  81. 	uchar read_add(uchar address);
  82.  
  83. 	dula=0; //初始化，段选置0
  84. 	wela=0; //初始化，片选置0
  85.  
  86. 	led1=1;	//初始化，二极管灯灭
  87. 	beep=1;	//初始化，蜂鸣器不响
  88.  
  89. 	num=0;
  90.  
  91. 	ms10=read_add(2);
  92. 	ms100=read_add(3);
  93. 	s=read_add(4);
  94. 	s10=read_add(5);
  95. 	min=read_add(6);
  96. 	min10=read_add(7);
  97.  
  98. 	if(ms10>=10) ms10=0;
  99. 	if(ms100>=10) ms100=0;
  100. 	if(s>=10) s=0;
  101. 	if(s10>=6) s10=0; 
  102. 	if(min>=10) min=0;
  103. 	if(min10>=6) min10=0;
  104. 	 
  105. 	display();
  106.  
  107. 	TMOD=0x10;//设置定时器0和1的工作方式为1（0001 0001）
  108. 	TH1=(65536-4608)/256; //装初值
  109. 	TL1=(65536-4608)%256; //装初值
  110. 	EA=1;//打开总中断
  111. 	ET1=1;//打开定时器1中断
  112. 	TR1=1;//启动定时器1
  113. }
  114.  
  115. void start() //启动信号
  116. {
  117. 	SDA=1; //数据线拉高
  118. 	delay();
  119. 	SCL=1; //时钟线拉高
  120. 	delay();
  121. 	SDA=0; //数据线拉低，在SCL高电平期间产生下降沿启动信号
  122. 	delay();	
  123. }
  124.  
  125. void respond() //应答信号
  126. {
  127. 	void delay();
  128.  
  129. 	uchar i=0;
  130. 	SCL=1; //时钟线拉高
  131. 	delay();
  132. 	while((SDA==1)&&(i<255)) i++; 
  133. 	//若一段时间主器件没有收到从器件的应答则默认
  134. 	//从器件已经收到数据不再等待应答信号
  135. 	//若不加这个延时退出，一旦从器件没有发送应答信号
  136. 	//程序将永远停留在此处
  137. 	SCL=0; //SCL高电平期间，SDA被从设备置低电平表示应答
  138. 	delay();
  139. }
  140.  
  141. void stop() //停止信号
  142. {
  143. 	void delay();
  144.  
  145. 	//SCL高电平期间，SDA一个上升沿产生停止信号
  146. 	SDA=0;
  147. 	delay();
  148. 	SCL=1;
  149. 	delay();
  150. 	SDA=1;
  151. 	delay();
  152. }
  153.  
  154. void write_byte(uchar Data) //写一个字节
  155. {
  156. 	void delay();
  157.  
  158. 	uchar i,temp;
  159. 	temp=Data;
  160. 	for(i=0;i<8;i++)
  161. 	{
  162. 		temp=temp<<1; 
  163. 		//串行发送字节是，需要将该字节的8位逐位发送
  164. 		//temp=temp<<1表示将temp左移一位，最高位将一如PSW寄存器的CY位中
  165. 		//然后将CY赋给SDA进而在SCL的控制下发送出去
  166. 		SCL=0;
  167. 		delay();
  168. 		SDA=CY;
  169. 		delay();
  170. 		SCL=1;
  171. 		delay();
  172. 	}
  173. 	SCL=0;
  174. 	delay();
  175. 	SDA=1;
  176. 	delay();
  177. }
  178.  
  179. uchar read_byte() //读一个字节
  180. {
  181. 	void delay();
  182.  
  183. 	uchar i,k; //定义的临时变量k
  184. 	SCL=0;
  185. 	delay();
  186. 	SDA=1;
  187. 	for(i=0;i<8;i++)
  188. 	{
  189. 		//串行接收字节时需要将8位逐位接收，再组合成一个字节
  190. 		//k左移一位后与SDA进行“或”运算
  191. 		//依次把8个独立的位放入一个字节中完成接收
  192. 		SCL=1;
  193. 		delay();
  194. 		k=(k<<1)|SDA;
  195. 		SCL=0;
  196. 		delay();
  197. 	}
  198. 	return k;
  199. }
  200.  
  201. void write_add(uchar address,uchar Data)
  202. {
  203. 	void start(); //启动信号
  204. 	void write_byte(uchar Data); //写一个信号
  205. 	void respond(); //应答信号
  206. 	void stop(); //停止信号
  207.  
  208. 	start();
  209. 	write_byte(0xa0);
  210. 	respond();
  211. 	write_byte(address);
  212. 	respond();
  213. 	write_byte(Data);
  214. 	respond();
  215. 	stop();
  216. }
  217.  
  218. uchar read_add(uchar address)
  219. {
  220. 	void start(); //启动信号
  221. 	void write_byte(uchar Data); //写一个信号
  222. 	uchar read_byte(); //读一个字节
  223. 	void respond(); //应答信号
  224. 	void stop(); //停止信号
  225.  
  226. 	uchar Data;
  227.  
  228. 	start();
  229. 	write_byte(0xa0);
  230. 	respond();
  231. 	write_byte(address);
  232. 	respond();
  233.  
  234. 	start();
  235. 	write_byte(0xa1);
  236. 	respond();
  237. 	Data=read_byte();
  238. 	stop();
  239. 	return Data;
  240. }
  241.  
  242. void display()
  243. {
  244. 	void wedu(uchar dula_num,uchar wela_num);
  245. 	for(wei=0;wei<6;wei++)
  246. 	{
  247. 		switch(wei)
  248. 		{
  249. 			case 0: wedu(ms10,wei);break;
  250. 			case 1: wedu(ms100,wei);break;
  251. 			case 2: wedu(s,wei);break;
  252. 			case 3: wedu(s10,wei);break;
  253. 			case 4: wedu(min,wei);break;
  254. 			case 5: wedu(min10,wei);break;
  255. 		}
  256. 		dula=1; //打开U1锁存端
  257. 		P0=0x00; //防止最高位数码管过亮
  258. 		dula=0; //关闭U1锁存端	
  259. 	}
  260. }
  261.  
  262.  
  263. void wedu(uchar dula_num,uchar wela_num)
  264. {
  265. 	wela=1; //打开U2锁存端
  266. 	P0=wela_table[wela_num]; //送入U2锁存端
  267. 	wela=0; //关闭U2锁存端
  268. 	P0=0xc0; //消影，防止P0残留电位信号干扰段选
  269. 	dula=1; //打开U1锁存端
  270. 	P0=dula_table[dula_num]; //送入段选信号
  271. 	dula=0; //关闭U1锁存端
  272. 	P0=0xff; //消影，防止P0残留电位信号干扰片选
  273. 	delayxms(1);
  274. }
  275.  
  276. void T1_time() interrupt 3 //中断程序
  277. {
  278. 	TH1=(65536-4608)/256; //装初值
  279. 	TL1=(65536-4608)%256; //装初值
  280. 	num++;
  281. 	if(num==2)
  282. 	{
  283. 		num=0;
  284. 		write=1; //写一次AT24C02	 
  285. 		ms10++;
  286. 		//write_add(2,ms10);
  287. 		if(ms10==10)
  288. 		{
  289. 			ms10=0;
  290. 			ms100++;
  291. 			//write_add(3,ms10);
  292. 			if(ms100==10)
  293. 			{
  294. 				ms100=0;
  295. 				s++;
  296. 				beep=0;
  297. 				delayxms(10);
  298. 				beep=1;
  299. 				//write_add(3,s);
  300. 				if(s==10)
  301. 				{
  302. 					s=0;
  303. 					s10++;
  304. 					//write_add(4,s10);
  305. 					if(s10==6)
  306. 					{
  307. 						s10=0;
  308. 						min++;
  309. 						//write_add(5,s10);
  310. 						if(min==10)
  311. 						{
  312. 							min=0;
  313. 							min10++;
  314. 							//write_add(6,min);
  315. 							if(min10==6)
  316. 							{
  317. 								min10=0;
  318. 							}
  319. 							//write_add(7,min10);
  320. 						}
  321. 					}
  322. 				}
  323. 			}
  324. 		}
  325. 	}
  326. }

        和chatgpt 交流的结果（将数字分为高低两个部分存储，但没有成功实现）：

  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4.  
  5. bit write=0; //写AT24C02的标志
  6.  
  7. sbit SDA=P2^0; //声明数据线端口
  8. sbit SCL=P2^1; //声明时钟线端口
  9. sbit dula=P2^6; //声明U1锁存器的锁存端
  10. sbit wela=P2^7; //声明U2锁存器的锁存端
  11. sbit led1=P1^0; //第一位发光二极管（0亮1灭）
  12. sbit beep=P2^3;	//声明蜂鸣器引脚（0响1灭）
  13.  
  14. uchar code dula_table[]={
  15. 	0x3f,0x06,0x5b,0x4f, //0,1,2,3
  16. 	0x66,0x6d,0x7d,0x07, //4,5,6,7
  17. 	0x7f,0x6f,0x77,0x7c, //8,9,10,11
  18. 	0x39,0x5e,0x79,0x71  //12,13,14,15
  19. };
  20.  
  21. uchar code wela_table[]=
  22. {
  23. 	  0xdf,0xef,0xf7,0xfb,0xfd,0xfe	//从右向左数第一到六位
  24. };
  25.  
  26. uchar dula_num,wela_num,num;
  27. uint ms10_memory,min10,min,s10,s,ms100,ms10,wei;
  28.  
  29. void main()
  30. {
  31. 	void init(); // 总线初始化
  32. 	void init_wedu(); //数码管显示和定时器初始化操作
  33. 	void write_add_uint(uchar address,uint Data);
  34. 	void display();
  35.  
  36. 	init();
  37. 	init_wedu();
  38. 	while(1)
  39. 	{
  40. 		display();
  41. 		if(write==1)
  42. 		{
  43. 			write=0;
  44. 			write_add_uint(2,ms10_memory);
  45. 		}
  46. 	}
  47. 		
  48. }
  49.  
  50. void delay() //微秒级延时函数，该延时函数大约延时4~5微秒，用于操作I2C总线时用
  51. {
  52. 	;;
  53. }
  54.  
  55. void delayxms(uint xms)
  56. {
  57. 	uint x,y;
  58. 	for(x=xms;x>0;x--)
  59. 		for(y=124;y>0;y--);	
  60. }    
  61.  
  62.  
  63. void init() // 总线初始化
  64. {
  65. 	void delay();
  66.  
  67. 	//将总线都拉高以释放总线
  68. 	SCL=1; //时钟线拉高
  69. 	delay();
  70. 	SDA=1; //数据线拉高
  71. 	delay();
  72. }
  73.  
  74. void init_wedu() //数码管显示和定时器初始化操作
  75. {
  76. 	uint read_add_uint(uchar address);
  77.  
  78. 	dula=0; //初始化，段选置0
  79. 	wela=0; //初始化，片选置0
  80.  
  81. 	led1=1;	//初始化，二极管灯灭
  82. 	beep=1;	//初始化，蜂鸣器不响
  83.  
  84. 	TMOD=0x10;//设置定时器0和1的工作方式为1（0001 0001）
  85. 	TH1=(65536-4608)/256; //装初值
  86. 	TL1=(65536-4608)%256; //装初值
  87. 	EA=1;//打开总中断
  88. 	ET1=1;//打开定时器1中断
  89. 	TR1=1;//启动定时器1
  90.  
  91. 	num=0;
  92.  
  93. 	ms10_memory=read_add_uint(2);
  94.  
  95. 	if(ms10_memory>36000) ms10_memory=0;
  96.  
  97. 	min10=ms10_memory/6000;
  98. 	min=ms10_memory%6000/600;
  99. 	s10=ms10_memory%6000%600/100;
  100. 	s=ms10_memory%6000%600%100;
  101. 	ms100=ms10_memory%6000%600%100/10;
  102. 	ms10=ms10_memory%6000%600%100%10;	
  103. }
  104.  
  105. void start() //启动信号
  106. {
  107. 	SDA=1; //数据线拉高
  108. 	delay();
  109. 	SCL=1; //时钟线拉高
  110. 	delay();
  111. 	SDA=0; //数据线拉低，在SCL高电平期间产生下降沿启动信号
  112. 	delay();	
  113. }
  114.  
  115. void respond() //应答信号
  116. {
  117. 	void delay();
  118.  
  119. 	uchar i=0;
  120. 	SCL=1; //时钟线拉高
  121. 	delay();
  122. 	while((SDA==1)&&(i<255)) i++; 
  123. 	//若一段时间主器件没有收到从器件的应答则默认
  124. 	//从器件已经收到数据不再等待应答信号
  125. 	//若不加这个延时退出，一旦从器件没有发送应答信号
  126. 	//程序将永远停留在此处
  127. 	SCL=0; //SCL高电平期间，SDA被从设备置低电平表示应答
  128. 	delay();
  129. }
  130.  
  131. void stop() //停止信号
  132. {
  133. 	void delay();
  134.  
  135. 	//SCL高电平期间，SDA一个上升沿产生停止信号
  136. 	SDA=0;
  137. 	delay();
  138. 	SCL=1;
  139. 	delay();
  140. 	SDA=1;
  141. 	delay();
  142. }
  143.  
  144. void write_byte(uchar Data) //写一个字节
  145. {
  146. 	void delay();
  147.  
  148. 	uchar i,temp;
  149. 	temp=Data;
  150. 	for(i=0;i<8;i++)
  151. 	{
  152. 		temp=temp<<1; 
  153. 		//串行发送字节是，需要将该字节的8位逐位发送
  154. 		//temp=temp<<1表示将temp左移一位，最高位将一如PSW寄存器的CY位中
  155. 		//然后将CY赋给SDA进而在SCL的控制下发送出去
  156. 		SCL=0;
  157. 		delay();
  158. 		SDA=CY;
  159. 		delay();
  160. 		SCL=1;
  161. 		delay();
  162. 	}
  163. 	SCL=0;
  164. 	delay();
  165. 	SDA=1;
  166. 	delay();
  167. }
  168.  
  169. uchar read_byte() //读一个字节
  170. {
  171. 	void delay();
  172.  
  173. 	uchar i,k; //定义的临时变量k
  174. 	SCL=0;
  175. 	delay();
  176. 	SDA=1;
  177. 	for(i=0;i<8;i++)
  178. 	{
  179. 		//串行接收字节时需要将8位逐位接收，再组合成一个字节
  180. 		//k左移一位后与SDA进行“或”运算
  181. 		//依次把8个独立的位放入一个字节中完成接收
  182. 		SCL=1;
  183. 		delay();
  184. 		k=(k<<1)|SDA;
  185. 		SCL=0;
  186. 		delay();
  187. 	}
  188. 	return k;
  189. }
  190.  
  191. void write_add_uint(uchar address, uint Data) 
  192. {
  193.     uchar data_low = (uchar)(Data & 0xFF);          // 获取低 8 位数据
  194.     uchar data_high = (uchar)((Data >> 8) & 0xFF);  // 获取高 8 位数据
  195.  
  196.     // 写入低字节
  197.     start();
  198.     write_byte(0xA0);   // 写入芯片地址
  199.     respond();
  200.     write_byte(address);    // 写入地址
  201.     respond();
  202.     write_byte(data_low);   // 写入低字节数据
  203.     respond();
  204.     stop();
  205.  
  206.     // 写入高字节
  207.     start();
  208.     write_byte(0xA0);   // 写入芯片地址
  209.     respond();
  210.     write_byte(address + 1);  // 写入地址的下一个位置
  211.     respond();
  212.     write_byte(data_high);  // 写入高字节数据
  213.     respond();
  214.     stop();
  215. }
  216.  
  217. uint read_add_uint(uchar address) 
  218. {
  219.     uchar high_byte, low_byte;
  220.  
  221.     // 读取低字节
  222.     start();
  223.     write_byte(0xA0);   // 写入芯片地址
  224.     respond();
  225.     write_byte(address);    // 写入地址
  226.     respond();
  227.     start();
  228.     write_byte(0xA1);   // 读取芯片地址
  229.     respond();
  230.     low_byte = read_byte();  // 读取低字节数据
  231.     respond();
  232.     stop();
  233.  
  234.     // 读取高字节
  235.     start();
  236.     write_byte(0xA0);   // 写入芯片地址	最末位表示方向：0
  237.     respond();
  238.     write_byte(address + 1);  // 写入地址的下一个位置
  239.     respond();
  240.     start();
  241.     write_byte(0xA1);   // 读取芯片地址	最末位表示方向：1
  242.     respond();
  243.     high_byte = read_byte();  // 读取高字节数据
  244.     respond();
  245.     stop();
  246.  
  247.     // 将高低字节合并为 uint 类型的数据并返回
  248.     return ((uint)high_byte << 8) | low_byte;
  249. }
  250.  
  251. void display()
  252. {
  253. 	void wedu(uchar dula_num,uchar wela_num);
  254. 	for(wei=0;wei<6;wei++)
  255. 	{
  256. 		switch(wei)
  257. 		{
  258. 			case 0: wedu(ms10,wei);break;
  259. 			case 1: wedu(ms100,wei);break;
  260. 			case 2: wedu(s,wei);break;
  261. 			case 3: wedu(s10,wei);break;
  262. 			case 4: wedu(min,wei);break;
  263. 			case 5: wedu(min10,wei);break;
  264. 		}	
  265. 	}
  266. }
  267.  
  268.  
  269. void wedu(uchar dula_num,uchar wela_num)
  270. {
  271. 	wela=1; //打开U2锁存端
  272. 	P0=wela_table[wela_num]; //送入U2锁存端
  273. 	wela=0; //关闭U2锁存端
  274. 	P0=0xc0; //消影，防止P0残留电位信号干扰段选
  275. 	dula=1; //打开U1锁存端
  276. 	P0=dula_table[dula_num]; //送入段选信号
  277. 	dula=0; //关闭U1锁存端
  278. 	P0=0xff; //消影，防止P0残留电位信号干扰片选
  279. 	delayxms(1);
  280. }
  281.  
  282. void T1_time() interrupt 3 //中断程序
  283. {
  284. 	TH1=(65536-4608)/256; //装初值
  285. 	TL1=(65536-4608)%256; //装初值
  286. 	num++;
  287. 	if(num==2)
  288. 	{
  289. 		num=0;
  290. 		ms10_memory++;
  291. 		if(ms10_memory == 36000) ms10_memory=0; //时间记满后重新计时
  292. 		write=1; //10ms写一次AT24C02	 
  293. 		ms10++;
  294. 		if(ms10==10)
  295. 		{
  296. 			ms10=0;
  297. 			ms100++;
  298. 		}
  299. 		if(ms100==10)
  300. 		{
  301. 			ms100=0;
  302. 			s++;
  303. 			beep=0;
  304. 			delayxms(10);
  305. 			beep=1;
  306. 		}
  307. 		if(s==10)
  308. 		{
  309. 			s=0;
  310. 			s10++;
  311. 		}
  312. 		if(s10==6)
  313. 		{
  314. 			s10=0;
  315. 			min++;
  316. 		}
  317. 		if(min==10)
  318. 		{
  319. 			min=0;
  320. 			min10++;
  321. 		}
  322. 		if(min10==6)
  323. 		{
  324. 			min10=0;
  325. 		}	
  326. 	}
  327. }

这个问题如果有机会再回来填坑

参考资料： 

[1] 郭天祥. 新概念51单片机C语言教程：入门、提高、开发、拓展全攻略[M]. 北京: 电子工业出版社, 2009.

[2] （51单片机）第三章-数码管显示原理及应用实现-中断_单片机复位后数码管显示机-CSDN博客

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/455997
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号