• 【单片机】13-实时时钟DS1302

    1.RTC的简介

    1.什么是实时时钟（RTC）

    （rtc for real time clock)

    （1）时间点和时间段的概念区分

    （2）单片机为什么需要时间点【一定的时间点干什么事情】

    （3）RTC如何存在于系统中（单片机内部集成 or 单片机外部扩展【DS1302】）

    2.DS1302

    1.数据手册

    DS1302中文数据手册 - 豆丁网

    2.SPI数字接口访问

    SPI通信协议【DS1302也使用这个协议】，两个芯片之间的通信

    3.内部存着一个时间点（年月日时分秒星期几）信息，可以读写，上电自动走表

    3.RTC学习关键点

    1.SPI接口的特征

    （1）3线（SCLK，RST，IO）或者4线（SCLK，RST，I，O）

    （2）同步：SPI是同步通信（表示主机【产生CLK】和从机【接受CLK】使用同一个SCLK）【同步通信有SCLK，异步没有SCLK】

    （3）主从：有主机和从机

    （4）串行：数据都从一根线进出【数据都是从IO进出】

    2.时序的理解

    3.编程实现

    2.原理图和接线

    1.原理图分析

    （1）DS1302引脚介绍

    JP595断开，是为了让P3.4在控制DS1302的时候，不影响74HC595工作

    JP1302接上，是为了让P3.4能控制到DS1302

    J11断开，是为了让P3.5在控制DS1302的时候，不影响NE555模块工作

    2.接线

    （1）详解接线设置的原理和必要性

    正常的产品一般不会这样设计，正常产品一般接线都是确定的，一般不会复用。

    开发板来说，主要是为了学习，所以会放很多给模块，所以在这个时候GPIO就不够使用，这时候就需要复用设计。一个引脚接多个模块就会互相影响（有2种可能：一个是A模块工作时B模块莫名其妙的工作，二是有时候B模块会影响到A模块的正常工作）。对于复用引脚的情况，接线的关键是确认目标模块接线OK时还不会影响到其他模块。

    3.数据手册带读

    https://www.dianyuan.com/upload/community/2014/02/22/1393058389-67878.pdf

    DS1302中文数据手册 - 豆丁网

    3.时序图的读法

    1.时序图的关键

    RST：由低电平变为高电平表示要开始工作了

    （1）横轴表示时间，纵轴表示同一个时间各个通信线的状态

    （2）静态或动态2个角度去看

    （3）主要SCLK的边缘--->会影响IO的电平状态【如果为上升沿，代表IO端口应该在快上升沿和结束上升沿时应该保持高电平】

    2.结合时序图的代码来理解时序

    写入数据

    1. /*******************************************************************************
    2. * 函 数 名       : ds1302_write_byte
    3. * 函数功能		 : DS1302写单字节
    4. * 输    入       : addr：地址/命令
    5. 				   dat：数据
    6. * 输    出    	 : 无
    7. *******************************************************************************/
    8. void ds1302_write_byte(u8 addr,u8 dat)
    9. {
    10. 	u8 i=0;
    11. 	//出于安全期间，在进入之前要将SCLK和RST进行初始化为0
    12. 	DS1302_RST=0;
    13. 	_nop_();	
    14. 	DS1302_CLK=0;//CLK低电平
    15. 	_nop_();
    16. 	
    17. 	DS1302_RST=1;//RST由低到高变化,表示要开始工作
    18. 	_nop_();
    19.  
    20. 	//开始传送八位数据
    21. 	for(i=0;i<8;i++)
    22. 	{
    23. 		//将数据放入IO口中
    24. 		DS1302_IO=addr&0x01;//数据从低位开始传送
    25. 		addr>>=1;
    26. 		DS1302_CLK=1; //上升沿
    27. 		//因为读取数据需要一段时间
    28. 		_nop_();//delay（）函数
    29. 		DS1302_CLK=0;//下降沿
    30. 		_nop_();		
    31. 	}
    32. 	for(i=0;i<8;i++)//循环8次，每次写1位，先写低位再写高位
    33. 	{
    34. 		DS1302_IO=dat&0x01;
    35. 		dat>>=1;
    36. 		DS1302_CLK=1;
    37. 		_nop_();
    38. 		DS1302_CLK=0;
    39. 		_nop_();		
    40. 	}
    41. 	//表示时序结束了
    42. 	DS1302_RST=0;//RST拉低
    43. 	DS1302_CLK=0;//为下一次循环做准备
    44. 	_nop_();	
    45. }

    读数据

    1. /*******************************************************************************
    2. * 函 数 名       : ds1302_read_byte
    3. * 函数功能		 : DS1302读单字节
    4. * 输    入       : addr：地址/命令
    5. * 输    出    	 : 读取的数据
    6. *******************************************************************************/
    7. u8 ds1302_read_byte(u8 addr)
    8. {
    9. 	u8 i=0;
    10. 	u8 temp=0;
    11. 	u8 value=0;
    12.  
    13. 	DS1302_RST=0;
    14. 	_nop_();	
    15. 	DS1302_CLK=0;//CLK低电平
    16. 	_nop_();
    17. 	DS1302_RST=1;//RST由低到高变化
    18. 	_nop_();
    19. 	
    20. 	for(i=0;i<8;i++)//循环8次，每次写1位，先写低位再写高位
    21. 	{
    22. 		DS1302_IO=addr&0x01;
    23. 		addr>>=1;	
    24. 		DS1302_CLK=1;
    25. 		_nop_();
    26. 		DS1302_CLK=0;//CLK由低到高产生一个上升沿，从而写入数据
    27. 		_nop_();		
    28. 	}
    29. 	for(i=0;i<8;i++)//循环8次，每次读1位，先读低位再读高位
    30. 	{
    31. 		temp=DS1302_IO;
    32. 		value=(temp<<7)|(value>>1);//先将value右移1位，然后temp左移7位，最后或运算
    33. 		DS1302_CLK=1;
    34. 		_nop_();
    35. 		DS1302_CLK=0;
    36. 		_nop_();		
    37. 	}
    38. 	DS1302_RST=0;//RST拉低
    39. 	_nop_();	
    40. 	DS1302_CLK=1;//对于实物中，P3.4口没有外接上拉电阻的，此处代码需要添加，使数据口有一个上升沿脉冲。
    41. 	_nop_();
    42. 	DS1302_IO = 0;
    43. 	_nop_();
    44. 	DS1302_IO = 1;
    45. 	_nop_();	
    46. 	return value;		
    47. }

    3.时序之上的东西

    1.大小端

    一个字节发出去，先发高位还是低位【IO=addr&0x01】表示先发低位

            【IO=addr&0x80】先发高位

    2.如何读写寄存器

    void ds1302_write_byte(u8 addr,u8 dat)

    addr：寄存器的地址

    dat:寄存器数据

    4.SPI时序特征

    1.低位在前

    2.DS1302在SCLK上升沿读取，SCLK下降沿写入

    上升沿：CLK=0;CLK=1;

    下降沿：CLK=1；CLK=0

    3.注意SCLK工作频率

    延时长短，太短则单片机来不及读取

    4.编程实践

    1.编写ds1302_write_reg

    DS1302是在上升沿读取【表示我们如果要写入数据，则应该在上升沿写入】

    1）先放入数据

    2）SCLK=1

    3）SCLK=0

    1. //****************************************************
    2. //向ds1302的内部寄存器addr写入一个值value
    3. /**
    4. addr:内部寄存器的地址
    5. value:内部寄存器的值
    6. */
    7. void ds1302_write_reg(unsigned char addr,unsigned char value){
    8. 	
    9. 	unsigned char i=0;
    10. 	unsigned char dat;
    11. 	
    12. 	//【第一步】起始部分 SCLK和RST为低电平，IO无所谓
    13. 	SCLK=0;
    14. 	delay();
    15. 	RST=0;
    16. 	delay();
    17.  
    18.     //此时开始工作
    19. 	RST=1;		//SCLK为低时，RST由低变高，意味着一个大的周期的开始
    20. 	delay();
    21. 	
    22. 	
    23. 	//【第二步】写入第一个字节，addr
    24. 	for(i=0;i<8;i++){
    25. 		dat=addr&0x01;  //SPI是从低位开始传输，此时取出最低位
    26. 		
    27. 		addr=addr>>1; //把addr右移一位，将原来的数值移回去
    28. 		delay();
    29. 		DSIO=dat;  //表示将取出的二进制字符输入到IO口，把要发送的Bit数据丢到IO引脚上去准备
    30. 		//一个循环写入一个字节
    31. 		SCLK=1;   //意味着有一个上升沿
    32. 		delay();
    33. 		SCLK=0;  //读走之后，一个小周期就结束，把SCLK拉低，是为了下一个小周期做准备
    34. 	}
    35. 	
    36. 	
    37. 	//【第三步】写入第二个字节，value
    38. 	for(i=0;i<8;i++){
    39. 		dat=value&0x01;  //SPI是从低位开始传输，此时取出最低位
    40. 		
    41. 		value=value>>1; //把addr右移一位，将原来的数值移回去
    42. 		
    43. 		DSIO=dat;  //表示将取出的二进制字符输入到IO口，把要发送的Bit数据丢到IO引脚上去准备
    44. 		delay();
    45. 		//一个循环写入一个字节
    46. 		SCLK=1;   //意味着有一个上升沿
    47. 		delay();
    48. 		SCLK=0;  //读走之后，一个小周期就结束，把SCLK拉低，是为了下一个小周期做准备
    49. 	}
    50. 	
    51. 	
    52. 	//【第四步】时序结束，IO无所谓
    53. 	SCLK=0;  //SCLK拉低是为了后面的周期时初始状态是正确的
    54. 	delay();
    55. 	RST=0;// 表示一个大周期的结束
    56. 	delay();
    57. }

    2.编写ds1302_read_reg

    下降沿写入【表示如果我们要读取数据，则应该在下降沿读取】

    1）SCLK=1；

    2）SCLC=0；

    3）在将数据取出

    1. //****************************************************
    2. //向ds1302的内部寄存器addr读入一个值，作为返回值
    3. /**
    4. addr:内部寄存器的地址
    5. value:内部寄存器的值
    6. */
    7. unsigned char ds1302_read_reg(unsigned char addr)
    8. {
    9. 	unsigned char i = 0;
    10. 	unsigned char dat = 0; 		// 用来存储读取到的一字节数据的
    11. 	unsigned char tmp = 0;
    12.  
    13. 	// 第1部分: 时序起始
    14. 	SCLK = 0;
    15. 	delay();
    16. 	RST = 0;
    17. 	delay();
    18.  
    19.  
    20.     //表示此时进入读取状态
    21. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    22. 	delay();
    23. 	// 第2部分: 写入要读取的寄存器地址，addr
    24. 	for (i=0; i<8; i++)
    25. 	{
    26. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    27. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    28. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    29. 		delay();				// 读走之后，一个小周期就完了
    30. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    31. 		delay();
    32. 		addr >>= 1;	   			// 把addr右移一位
    33. 	}
    34. 	// 第3部分: 读出一字节DS1302返回给我们的值【SPI下降沿才可以进行读取】
    35. 	dat = 0;
    36. 	for (i=0; i<8; i++)
    37. 	{
    38. 	// 在前面向ds1302写入addr的最后一个bit后，ds1302就会将读取到的寄存器值
    39. 	// 的第一个bit放入到IO引脚上，所以我们应该先读取IO再制造下降沿然后继续
    40. 	// 读取下一个bit
    41. 		tmp = DSIO;            //DSIO一次传输一个bit
    42. 		dat |= (tmp << i);		// 读出来的数值是低位在前的
    43. 		SCLK = 1;  				// 由于上面SCLK是低，所以要先拉到高
    44. 		delay();
    45. 		SCLK = 0;				// 拉低SCLK制造一个下降沿
    46. 		delay();
    47. 	}
    48. 	// 第4部分: 时序结束
    49. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    50. 	delay();
    51. 	RST = 0;					// RST拉低意味着一个大周期的结束
    52. 	delay();
    53.  
    54. 	// 第5部分：解决读取时间是ff的问题
    55. 	DSIO = 0;
    56.  
    57. 	return dat;
    58. }

    3.读取时间

    1.DS1302的时间寄存器的地址

    如果要读取秒寄存器，地址是:0b 1000 0001(0x81)

    如果要写入秒寄存器 ，地址是:0b 1000 0000(0x80)

    2.移植串口输出代码，将读取到的时间通过串口输出显示

    1.  
    2. //**************************************
    3. //定义SPI的三个引脚
    4. sbit DSIO=P3^4;
    5. sbit RST=P3^5;
    6. sbit SCLK=P3^6;
    7.  
    8.  
    9.  
    10. //加入delay，是为了防止速度过快，单片机感受不到
    11. void delay(){
    12. 	
    13. 	unsigned char i;
    14. 	for(i=0;i<3;i++){
    15. 	}
    16. 	
    17. }
    18.  
    19. //********************************************************
    20. //因为51单片机的设计本身RAM比较少而Flash比较多，像这里定义的数组内部
    21. //的内容是不会变的（常量数组），我们就可以使用code关键字，让编译器帮我们
    22. //把这个数组放在flash中而不是RAM，这样做可以省一些RAM
    23. //判断要读取时分秒年月日星期几
    24. unsigned char code READ_RTC_ADDR[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
    25.  
    26.  
    27. //存储时间
    28. unsigned char time[7];// 用来存储读取出来的时间，格式是：秒分时日月周年 
    29.  
    30. //****************************************************
    31. //向ds1302的内部寄存器addr写入一个值value
    32. /**
    33. addr:内部寄存器的地址
    34. value:内部寄存器的值
    35. */
    36. void ds1302_write_reg(unsigned char addr,unsigned char value){
    37. 	
    38. 	unsigned char i=0;
    39. 	unsigned char dat;
    40. 	
    41. 	//【第一步】起始部分 SCLK和RST为低电平，IO无所谓
    42. 	SCLK=0;
    43. 	delay();
    44. 	RST=0;
    45. 	delay();
    46. 	RST=1;		//SCLK为低时，RST由低变高，意味着一个大的周期的开始
    47. 	delay();
    48. 	
    49. 	
    50. 	//【第二步】写入第一个字节，addr
    51. 	for(i=0;i<8;i++){
    52. 		dat=addr&0x01;  //SPI是从低位开始传输，此时取出最低位
    53. 		
    54. 		addr=addr>>1; //把addr右移一位，将原来的数值移回去
    55. 		delay();
    56. 		DSIO=dat;  //表示将取出的二进制字符输入到IO口，把要发送的Bit数据丢到IO引脚上去准备
    57. 		//一个循环写入一个字节
    58. 		SCLK=1;   //意味着有一个上升沿
    59. 		delay();
    60. 		SCLK=0;  //读走之后，一个小周期就结束，把SCLK拉低，是为了下一个小周期做准备
    61. 		delay();
    62. 	}
    63. 	
    64. 	
    65. 	//【第三步】写入第二个字节，value
    66. 	for(i=0;i<8;i++){
    67. 		dat=value&0x01;  //SPI是从低位开始传输，此时取出最低位
    68. 		
    69. 		value=value>>1; //把addr右移一位，将原来的数值移回去
    70. 		
    71. 		DSIO=dat;  //表示将取出的二进制字符输入到IO口，把要发送的Bit数据丢到IO引脚上去准备
    72. 		delay();
    73. 		//一个循环写入一个字节
    74. 		SCLK=1;   //意味着有一个上升沿
    75. 		delay();
    76. 		SCLK=0;  //读走之后，一个小周期就结束，把SCLK拉低，是为了下一个小周期做准备
    77. 	}
    78. 	
    79. 	
    80. 	//【第四步】时序结束，IO无所谓
    81. 	SCLK=0;  //SCLK拉低是为了后面的周期时初始状态是正确的
    82. 	delay();
    83. 	RST=0;// 表示一个大周期的结束
    84. 	delay();
    85. }
    86.  
    87.  
    88.  
    89. //****************************************************
    90. //向ds1302的内部寄存器addr读入一个值，作为返回值
    91. /**
    92. addr:内部寄存器的地址
    93. value:内部寄存器的值
    94. */
    95. unsigned char ds1302_read_reg(unsigned char addr)
    96. {
    97. 	unsigned char i = 0;
    98. 	unsigned char dat = 0; 		// 用来存储读取到的一字节数据的
    99. 	unsigned char tmp = 0;        //因为51单片机不允许DSIO进行移位，所以使用中间变量
    100.  
    101. 	// 第1部分: 时序起始
    102. 	SCLK = 0;
    103. 	delay();
    104. 	RST = 0;
    105. 	delay();
    106. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    107. 	delay();
    108. 	// 第2部分: 写入要读取的寄存器地址，addr
    109. 	for (i=0; i<8; i++)
    110. 	{
    111. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    112. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    113. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    114. 		delay();				// 读走之后，一个小周期就完了
    115. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    116. 		delay();
    117. 		addr >>= 1;	   			// 把addr右移一位
    118. 	}
    119. 	// 第3部分: 读出一字节DS1302返回给我们的值【SPI下降沿才可以进行读取】
    120. 	dat = 0;
    121. 	for (i=0; i<8; i++)
    122. 	{
    123. 	// 在前面向ds1302写入addr的最后一个bit后，ds1302就会将读取到的寄存器值
    124. 	// 的第一个bit放入到IO引脚上，所以我们应该先读取IO再制造下降沿然后继续
    125. 	// 读取下一个bit
    126. 		tmp = DSIO;
    127. 		dat |= (tmp << i);		// 读出来的数值是低位在前的
    128. 		SCLK = 1;  				// 由于上面SCLK是低，所以要先拉到高
    129. 		delay();
    130. 		SCLK = 0;				// 拉低SCLK制造一个下降沿
    131. 		delay();
    132. 	}
    133. 	// 第4部分: 时序结束
    134. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    135. 	delay();
    136. 	RST = 0;					// RST拉低意味着一个大周期的结束
    137. 	delay();
    138.  
    139. 	// 第5部分：解决读取时间是ff的问题
    140. 	DSIO = 0;
    141.  
    142. 	return dat;
    143. }
    144.  
    145. //******************************************************
    146. //读取时间
    147. void ds1302_read_time(void){
    148. 	
    149. 	unsigned char i=0;
    150. 	for(i=0;i<7;i++){
    151. 		time[i]=ds1302_read_reg(READ_RTC_ADDR[i]);
    152. 	}
    153. 	
    154. }
    155.  
    156.  
    157.  
    158. void main(){
    159. 	ds1302_read_time();
    160. }

     5.使用串口进行调试

    1.注意波特率设置和晶振设置

    2.注意串口相关的接线设置

    3.测试串口输出效果

    4.注意二进制显示和文本方式显示

    5.注意串口助手打开时烧录软件是不能使用的

    1.将读取到的时间输出到串口上

    1.  
    2. //*************************************************************
    3. //通过串口将7个时间以二进制的方式输出到串口助手上
    4. void debug_print_time(void)
    5. {
    6. 	unsigned char i=0;
    7. 	while(1){
    8. 		
    9. 		//1.从ds1302读取时间
    10. 		ds1302_read_time();
    11. 		
    12. 		//2.for循环内打印一组7个时间
    13. 		for(i=0;i<7;i++){
    14. 			uart_send_byte(i);
    15. 		}
    16. 		
    17. 		//3.延时900ms后在继续下一个周期
    18. 		Delay900000us();
    19. 	}
    20. }
    21.  
    22.  
    23. //串口发送函数,发送一个字节【单个字节】
    24. void uart_send_byte(unsigned char c){
    25. 	
    26. 	//【第一步】发送一个字节
    27. 	SBUF=c;
    28. 	//【第二步】先确认串口发送部分没有在忙
    29. 	while(!TI);//TI=0，表示在忙
    30. 	//【第三步】软件复位TI标志位---数据手册要求的
    31. 	TI=0;
    32. }
    33.  
    34.  
    35. void Delay900000us()		//@12.000MHz
    36. {
    37. 	unsigned char i, j, k;
    38.  
    39. 	_nop_();
    40. 	_nop_();
    41. 	i = 42;
    42. 	j = 10;
    43. 	k = 168;
    44. 	do
    45. 	{
    46. 		do
    47. 		{
    48. 			while (--k);
    49. 		} while (--j);
    50. 	} while (--i);
    51. }
    52.  
    53. //****************************************************
    54. //向ds1302的内部寄存器addr读入一个值，作为返回值
    55. /**
    56. addr:内部寄存器的地址
    57. value:内部寄存器的值
    58. */
    59. unsigned char ds1302_read_reg(unsigned char addr)
    60. {
    61. 	unsigned char i = 0;
    62. 	unsigned char dat = 0; 		// 用来存储读取到的一字节数据的
    63. 	unsigned char tmp = 0;
    64.  
    65. 	// 第1部分: 时序起始
    66. 	SCLK = 0;
    67. 	delay();
    68. 	RST = 0;
    69. 	delay();
    70. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    71. 	delay();
    72. 	// 第2部分: 写入要读取的寄存器地址，addr
    73. 	for (i=0; i<8; i++)
    74. 	{
    75. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    76. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    77. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    78. 		delay();				// 读走之后，一个小周期就完了
    79. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    80. 		delay();
    81. 		addr >>= 1;	   			// 把addr右移一位
    82. 	}
    83. 	// 第3部分: 读出一字节DS1302返回给我们的值【SPI下降沿才可以进行读取】
    84. 	dat = 0;
    85. 	for (i=0; i<8; i++)
    86. 	{
    87. 	// 在前面向ds1302写入addr的最后一个bit后，ds1302就会将读取到的寄存器值
    88. 	// 的第一个bit放入到IO引脚上，所以我们应该先读取IO再制造下降沿然后继续
    89. 	// 读取下一个bit
    90. 		tmp = DSIO;
    91. 		dat |= (tmp << i);		// 读出来的数值是低位在前的
    92. 		SCLK = 1;  				// 由于上面SCLK是低，所以要先拉到高
    93. 		delay();
    94. 		SCLK = 0;				// 拉低SCLK制造一个下降沿
    95. 		delay();
    96. 	}
    97. 	// 第4部分: 时序结束
    98. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    99. 	delay();
    100. 	RST = 0;					// RST拉低意味着一个大周期的结束
    101. 	delay();
    102.  
    103. 	// 第5部分：解决读取时间是ff的问题
    104. 	DSIO = 0;
    105.  
    106. 	return dat;
    107. }

    2.问题解决

    状况：

    （1）代码确实得到了一系列的时间数据

    （2）秒确实在变化，而且规律正确

    （3）时间数据中有一些FF是不合理的，不应该出现的。

    总结规律：

    FF总是出现在前一个周期数字是偶数时，前一个如果是奇数则不会出现

    解决方法：解决读取时间为ff

    1.硬件上在IO线上设置10k的电阻做弱上拉电阻处理

    2.如果没有做弱上拉，也有解决方法。在代码的读取寄存器时序之后，加一个将IO置为低电平的代码进去就可以。

    1. //****************************************************
    2. //向ds1302的内部寄存器addr读入一个值，作为返回值
    3. /**
    4. addr:内部寄存器的地址
    5. value:内部寄存器的值
    6. */
    7. unsigned char ds1302_read_reg(unsigned char addr)
    8. {
    9. 	
    10. 	
    11. 	unsigned char i = 0;
    12. 	unsigned char dat = 0; 		// 用来存储读取到的一字节数据的
    13. 	unsigned char tmp = 0;
    14.  
    15. 	// 第1部分: 时序起始
    16. 	SCLK = 0;
    17. 	delay();
    18. 	RST = 0;
    19. 	delay();
    20. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    21. 	delay();
    22. 	// 第2部分: 写入要读取的寄存器地址，addr
    23. 	for (i=0; i<8; i++)
    24. 	{
    25. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    26. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    27. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    28. 		delay();				// 读走之后，一个小周期就完了
    29. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    30. 		delay();
    31. 		addr >>= 1;	   			// 把addr右移一位
    32. 	}
    33. 	// 第3部分: 读出一字节DS1302返回给我们的值【SPI下降沿才可以进行读取】
    34. 	dat = 0;
    35. 	for (i=0; i<8; i++)
    36. 	{
    37. 	// 在前面向ds1302写入addr的最后一个bit后，ds1302就会将读取到的寄存器值
    38. 	// 的第一个bit放入到IO引脚上，所以我们应该先读取IO再制造下降沿然后继续
    39. 	// 读取下一个bit
    40. 		tmp = DSIO;
    41. 		dat |= (tmp << i);		// 读出来的数值是低位在前的
    42. 		SCLK = 1;  				// 由于上面SCLK是低，所以要先拉到高
    43. 		delay();
    44. 		SCLK = 0;				// 拉低SCLK制造一个下降沿
    45. 		delay();
    46. 	}
    47. 	// 第4部分: 时序结束
    48. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    49. 	delay();
    50. 	RST = 0;					// RST拉低意味着一个大周期的结束
    51. 	delay();
    52.  
    53. 	// 第5部分：解决读取时间是ff的问题
    54. 	DSIO = 0;
    55.  
    56. 	return dat;
    57. }

    6.DS1302的时间格式详解

    1.BCD码

    上面显示的时间都是十六进制

    1.什么是BCD码

    （1）BCD码是一种数字编码，这种计数编码有个特点：很像十进制和十六进制的结合。看起来很像十进制（29下来是30而不是2A），BCD码实际是用十六进制来表示的。【BCD码的21其实在计算机中就是0x21】

    BCD中只有0-9，而没有ABCDEF等字目。

    综合来说：BCD码其实就是看起来很像十进制数的十六进制。

    意思是：BCD码本质是十六进制数，但是因为它没有ABCDEF，所以看起来很像十进制数。

    （2）BCD码的意义：十六进制适合计算机进行计算，十进制适合人看和理解

    2.区别BCD码，16进制，10进制，三种数

    C语言：十进制、BCD码互换_51CTO博客_bcd码和十进制的互相转换

    2.年份从2000开始

    直接读出的数+2000就是当前的年份，比如读出的BCD码是16，对应0x16，其实就表示数字16，所以读出的是2016年。

    7.向DS1302写入时间

    1.读时间函数

    1. //********************************************************
    2. //因为51单片机的设计本身RAM比较少而Flash比较多，像这里定义的数组内部
    3. //的内容是不会变的（常量数组），我们就可以使用code关键字，让编译器帮我们
    4. //把这个数组放在flash中而不是RAM，这样做可以省一些RAM
    5. //判断要读取时分秒年月日星期几
    6. unsigned char code READ_RTC_ADDR[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
    7.  
    8.  
    9. //****************************************************
    10. //向ds1302的内部寄存器addr读入一个值，作为返回值
    11. /**
    12. addr:内部寄存器的地址
    13. value:内部寄存器的值
    14. */
    15. unsigned char ds1302_read_reg(unsigned char addr)
    16. {
    17. 	
    18. 	
    19. 	unsigned char i = 0;
    20. 	unsigned char dat = 0; 		// 用来存储读取到的一字节数据的
    21. 	unsigned char tmp = 0;
    22.  
    23. 	// 第1部分: 时序起始
    24. 	SCLK = 0;
    25. 	delay();
    26. 	RST = 0;
    27. 	delay();
    28. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    29. 	delay();
    30. 	// 第2部分: 写入要读取的寄存器地址，addr
    31. 	for (i=0; i<8; i++)
    32. 	{
    33. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    34. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    35. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    36. 		delay();				// 读走之后，一个小周期就完了
    37. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    38. 		delay();
    39. 		addr >>= 1;	   			// 把addr右移一位
    40. 	}
    41. 	// 第3部分: 读出一字节DS1302返回给我们的值【SPI下降沿才可以进行读取】
    42. 	dat = 0;
    43. 	for (i=0; i<8; i++)
    44. 	{
    45. 	// 在前面向ds1302写入addr的最后一个bit后，ds1302就会将读取到的寄存器值
    46. 	// 的第一个bit放入到IO引脚上，所以我们应该先读取IO再制造下降沿然后继续
    47. 	// 读取下一个bit
    48. 		tmp = DSIO;
    49. 		dat |= (tmp << i);		// 读出来的数值是低位在前的
    50. 		SCLK = 1;  				// 由于上面SCLK是低，所以要先拉到高
    51. 		delay();
    52. 		SCLK = 0;				// 拉低SCLK制造一个下降沿
    53. 		delay();
    54. 	}
    55. 	// 第4部分: 时序结束
    56. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    57. 	delay();
    58. 	RST = 0;					// RST拉低意味着一个大周期的结束
    59. 	delay();
    60.  
    61. 	// 第5部分：解决读取时间是ff的问题
    62. 	DSIO = 0;
    63.  
    64. 	return dat;
    65. }
    66.  
    67.  
    68. //存储时间
    69. unsigned char time[7];// 用来存储读取出来的时间，格式是：秒分时日月周年 
    70.  
    71. //******************************************************
    72. //读取时间
    73. void ds1302_read_time(void){
    74. 	
    75. 	unsigned char i=0;
    76. 	for(i=0;i<7;i++){
    77. 		time[i]=ds1302_read_reg(READ_RTC_ADDR[i]);
    78. 	}
    79. 	
    80. }

    2.写时间函数

    1.数组的设置

    1. //读取时间用到的数组：因为是【读】所以最后一位是1
    2. unsigned char code READ_RTC_ADDR[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
    3. //写入时间用到的数组：因为是【写】所以最后一位是0,所以比READ_RTC_ADDR中的地址分别少1
    4. unsigned char code WRITE_RTC_ADDR[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c};

    2.“写保护”设置

        ds1302_write_reg(0x8E，0x00);  //去掉写保护

        ds1302_write_reg(0x8E,0x80);//打开写保护

    1. 	ds1302_write_reg(0x8E，0x00);  //去掉写保护
    2. 	for(i=0;i<7;i++){
    3. 		ds1302_write_reg(WRITE_RTC_ADDR[i],time[i]);
    4. 	}
    5. 	
    6. 	ds1302_write_reg(0x8E,0x80);//打开写保护

    3.注意写入地址和读出地址不同

    1. //******************************************************
    2. //写入时间
    3. void ds1302_write_time(void)
    4. {
    5. 		unsigned char i=0;
    6. 	//准备好要写入的时间
    7. 	time[0]=0x24;  //对应24s
    8. 	time[1]=0x39;// 对应39m
    9. 	time[2]=0x11;  //对应11h
    10. 	time[3]=0x30;  //对应30日
    11. 	time[4]=0x11;		//对应12月
    12. 	time[5]=0x02;  //对应星期二
    13. 	time[6]=0x16;  //对应2016年
    14. 	
    15. 	ds1302_write_reg(0x8E，0x00);  //去掉写保护
    16. 	for(i=0;i<7;i++){
    17. 		ds1302_write_reg(WRITE_RTC_ADDR[i],time[i]);
    18. 	}
    19. 	
    20. 	ds1302_write_reg(0x8E,0x80);//打开写保护
    21. }

    8.对程序进行规整

    1.如何规整

    （1）多文件方式实现，意思是多个.c文件来实现

    （2）多文件方式的目的是让各个功能模块分开实现，这样方便组织和查找

    2.c文件和头文件

    （1）c文件是c语言源文件，h文件是头文件

    （2）源文件主要用来放：函数和全局变量的定义

    （3）头文件主要用来存放：函数和全局变量的声明，宏定义，结构体共用体类型定义等

    （4）一般是一个源文件就配一个头文件

    （5）一般包含自己建立的头文件时用”“而不用<>

    （6）头文件中还有固定格式

    #ifndef __UART_H__
    #define __UART_H__
    #endif

    uart.h

    1. #ifndef __UART_H__
    2. #define __UART_H__
    3.  
    4. #include 
    5.  
    6.  
    7.  
    8.  
    9.  
    10. void uart_init(void);
    11. void uart_send_byte(unsigned char c);
    12.  
    13.  
    14.  
    15.  
    16.  
    17. #endif
    18.  
    19.  
    20.

    ds1302.h

    1. #ifndef __DS1302_H__
    2. #define __DS1302_H__
    3.  
    4.  
    5.  
    6.  
    7. void delay(void);
    8. //void delay1s(void);
    9. void delay900ms(void);
    10. void ds1302_write_reg(unsigned char addr, unsigned char value);
    11. unsigned char ds1302_read_reg(unsigned char addr);
    12. void ds1302_read_time(void);
    13. void ds1302_write_time(void);
    14. void debug_print_time(void);
    15.  
    16.  
    17.  
    18.  
    19.  
    20. #endif
    21.  
    22.  
    23.  
    24.  
    25.

    main.c

    1. #include "uart.h"
    2. #include "ds1302.h"
    3.  
    4.  
    5. void main(void)
    6. {
    7. //	unsigned char i = 0;
    8.  
    9. 	uart_init();
    10.  
    11. 	ds1302_write_time();
    12. /*
    13. 	// 测试串口工作
    14. 	for (i=0; i<255; i++)
    15. 	{
    16. 		uart_send_byte(i);
    17. 		delay1s();
    18. 	}
    19. 	while (1);
    20. */
    21. 	debug_print_time();
    22. }

    ds1302.c

    1. #include 
    2. #include 
    3. #include "uart.h"
    4. #include "ds1302.h"
    5.  
    6.  
    7.  
    8. /**************  全局变量定义  *************************************/
    9.  
    10. // 定义SPI的三根引脚
    11. sbit DSIO	= P3^4;
    12. sbit RST	= P3^5;
    13. sbit SCLK	= P3^6;
    14.  
    15. // 因为51单片机的设计本身RAM比较少而Flash稍微多一些，像这里定义的数组内部
    16. // 的内容是不会变的（常量数组），我们就可以使用code关键字，让编译器帮我们
    17. // 把这个数组放在flash中而不是ram中，这样做可以省一些ram。
    18. unsigned char code READ_RTC_ADDR[7] = {0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d}; 
    19. unsigned char code WRITE_RTC_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};
    20. unsigned char time[7];		// 用来存储读取的时间的，格式是：秒分时日月周年
    21.  
    22.  
    23.  
    24.  
    25. // 有用函数
    26. void delay(void)
    27. {
    28. 	unsigned char i;
    29. 	for (i=0; i<3; i++);
    30. }
    31. /*
    32. void delay1s(void)   //误差 0us
    33. {
    34.     unsigned char a,c;
    35.     for(c=167;c>0;c--)
    36.             for(a=16;a>0;a--);
    37.     _nop_();  //if Keil,require use intrins.h
    38. }
    39. */
    40.  
    41. void delay900ms(void)   //误差 -0.000000000205us
    42. {
    43.     unsigned char a,b,c;
    44.     for(c=127;c>0;c--)
    45.         for(b=128;b>0;b--)
    46.             for(a=24;a>0;a--);
    47. }
    48.  
    49. // 向ds1302的内部寄存器addr写入一个值value
    50. void ds1302_write_reg(unsigned char addr, unsigned char value)
    51. {
    52. 	unsigned char i = 0;
    53. 	unsigned char dat = 0;
    54.  
    55. 	// 第1部分: 时序起始
    56. 	SCLK = 0;
    57. 	delay();
    58. 	RST = 0;
    59. 	delay();
    60. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    61. 	delay();
    62. 	// 第2部分: 写入第1字节，addr
    63. 	for (i=0; i<8; i++)
    64. 	{
    65. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    66. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    67. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    68. 		delay();				// 读走之后，一个小周期就完了
    69. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    70. 		delay();
    71. 		addr >>= 1;	   			// 把addr右移一位
    72. 	}
    73. 	// 第3部分: 写入第2字节，value
    74. 	for (i=0; i<8; i++)
    75. 	{
    76. 		dat = value & 0x01;	 	// SPI是从低位开始传输的
    77. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    78. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    79. 		delay();				// 读走之后，一个小周期就完了
    80. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    81. 		delay();
    82. 		value = value >> 1;	   	// 把addr右移一位
    83. 	}
    84. 	// 第4部分: 时序结束
    85. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    86. 	delay();
    87. 	RST = 0;					// RST拉低意味着一个大周期的结束
    88. 	delay();
    89. }
    90.  
    91.  
    92. // 从ds1302的内部寄存器addr读出一个值，作为返回值
    93. unsigned char ds1302_read_reg(unsigned char addr)
    94. {
    95. 	unsigned char i = 0;
    96. 	unsigned char dat = 0; 		// 用来存储读取到的一字节数据的
    97. 	unsigned char tmp = 0;
    98.  
    99. 	// 第1部分: 时序起始
    100. 	SCLK = 0;
    101. 	delay();
    102. 	RST = 0;
    103. 	delay();
    104. 	RST = 1;  		// SCLK为低时，RST由低变高，意味着一个大的周期的开始
    105. 	delay();
    106. 	// 第2部分: 写入要读取的寄存器地址，addr
    107. 	for (i=0; i<8; i++)
    108. 	{
    109. 		dat = addr & 0x01;	 	// SPI是从低位开始传输的
    110. 		DSIO = dat;	 			// 把要发送的bit数据丢到IO引脚上去准备好
    111. 		SCLK = 1;		 		// 制造上升沿，让DS1302把IO上的值读走
    112. 		delay();				// 读走之后，一个小周期就完了
    113. 		SCLK = 0;				// 把SCLK拉低，是为了给下一个小周期做准备
    114. 		delay();
    115. 		addr >>= 1;	   			// 把addr右移一位
    116. 	}
    117. 	// 第3部分: 读出一字节DS1302返回给我们的值
    118. 	dat = 0;
    119. 	for (i=0; i<8; i++)
    120. 	{
    121. 	// 在前面向ds1302写入addr的最后一个bit后，ds1302就会将读取到的寄存器值
    122. 	// 的第一个bit放入到IO引脚上，所以我们应该先读取IO再制造下降沿然后继续
    123. 	// 读取下一个bit
    124. 		tmp = DSIO;
    125. 		dat |= (tmp << i);		// 读出来的数值是低位在前的
    126. 		SCLK = 1;  				// 由于上面SCLK是低，所以要先拉到高
    127. 		delay();
    128. 		SCLK = 0;				// 拉低SCLK制造一个下降沿
    129. 		delay();
    130. 	}
    131. 	// 第4部分: 时序结束
    132. 	SCLK = 0;				  	// SCLK拉低为了后面的周期时初始状态是对的
    133. 	delay();
    134. 	RST = 0;					// RST拉低意味着一个大周期的结束
    135. 	delay();
    136.  
    137. 	// 第5部分：解决读取时间是ff的问题
    138. 	DSIO = 0;
    139.  
    140. 	return dat;
    141. }
    142.  
    143.  
    144. void ds1302_read_time(void)
    145. {
    146. 	unsigned char i = 0;
    147. 	for (i=0; i<7; i++)
    148. 	{
    149. 		time[i] = ds1302_read_reg(READ_RTC_ADDR[i]);
    150. 	}
    151. }
    152.  
    153. void ds1302_write_time(void)
    154. {
    155. 	unsigned char i = 0;
    156.  
    157. 	// 准备好要写入的时间
    158. 	time[0] = 0x24;				// 对应 24s
    159. 	time[1] = 0x39;				// 对应 39m
    160. 	time[2] = 0x11;				// 对应 11h
    161. 	time[3] = 0x06;				// 对应 6日
    162. 	time[4] = 0x12;				// 对应 12月
    163. 	time[5] = 0x02;				// 对应 星期2
    164. 	time[6] = 0x16;				// 对应 2016年
    165.  
    166. 	ds1302_write_reg(0x8E, 0x00);	// 去掉写保护
    167. 	for (i=0; i<7; i++)
    168. 	{
    169. 		ds1302_write_reg(WRITE_RTC_ADDR[i], time[i]);
    170. 	}
    171. 	ds1302_write_reg(0x8E, 0x80);	// 打开写保护
    172. }
    173.  
    174.  
    175.  
    176.  
    177. // 通过串口将7个时间以二进制方式输出在串口助手上
    178. void debug_print_time(void)
    179. {
    180. 	unsigned char i = 0;
    181.  
    182. 	while (1)
    183. 	{
    184. 		// 1 从DS1302读取时间
    185. 		ds1302_read_time();
    186.  
    187. 		// 2 for循环内打印一组7个时间
    188. 		for (i=0; i<7; i++)
    189. 		{
    190. 			uart_send_byte(time[i]);	
    191. 		}
    192.  
    193. 		// 3 延时900ms后再继续下个周期
    194. 	   	delay900ms();
    195. 	}	
    196. }
    197.

    uart.c

    1. #include "uart.h"
    2.  
    3.  
    4. // 串口设置为: 波特率9600、数据位8、停止位1、奇偶校验无
    5. // 使用的晶振是11.0592MHz的，注意12MHz和24MHz的不行
    6. void uart_init(void)
    7. {
    8. 	// 波特率9600
    9. 	SCON = 0x50;   	// 串口工作在模式1（8位串口）、允许接收
    10. 	PCON = 0x00;	// 波特率不加倍
    11.  
    12. 	// 通信波特率相关的设置
    13. 	TMOD = 0x20;	// 设置T1为模式2
    14. 	TH1 = 253;
    15. 	TL1 = 253;	   	// 8位自动重装，意思就是TH1用完了之后下一个周期TL1会
    16. 					// 自动重装到TH1去
    17.  
    18. 	TR1 = 1;		// 开启T1让它开始工作
    19. 	ES = 1;
    20. 	EA = 1;
    21. }
    22.  
    23. // 通过串口发送1个字节出去
    24. void uart_send_byte(unsigned char c)
    25. {
    26.    // 第1步，发送一个字节
    27.    SBUF = c;
    28.  
    29.    // 第2步，先确认串口发送部分没有在忙
    30.    while (!TI);
    31.  
    32.    // 第3步，软件复位TI标志位
    33.    TI = 0;
    34. }
    35.
  • 相关阅读:
    代码随想录刷题Day55 | 392. 判断子序列 | 115. 不同的子序列
    （1）(1.16) Maxbotix I2C声纳
    MTK平台拍照录像如何实现Mirror效果
    Java项目：ssm+mysql+maven养老院管理系统
    day36-xml
    大数据存储与处理
    全能型开源数据库监控平台 - lepus
    2023年8月知识复习
    LTC4056/TP4056国产替代DP4056锂电池充电保护芯片
    快速熟悉C++之常用语法
  • 原文地址：https://blog.csdn.net/m0_63077733/article/details/133437970