自学AVR单片机二十二（时钟芯片DS1302）

一、简单原理
        DS1302是一种高性能、低功耗、带RAM的实时时钟芯片，它可以对年、月、日、星期、天、时、分、秒自动计时，并且具有闰年补偿功能。
        DS1302具有宽电压工作范围：2.7-5.5v。
       DS1302采用3线串行接口与单片机进行同步通信，并可采用突发方式一次传送多字节的时钟信号或RAM数据。
        DS1302内部有一个31字节的用于临时存放数据的RAM寄存器。
       DS1302还具备主电源/后备电源供电的双电源引脚，可以自动切换电源，并且提供了对后备电源进行涓细电流充电的能力。
       DS1302的引脚说明如下：

Vcc1为后备电源，VCC2为主电源。在主电源关闭的情况下，也能保持时钟的连续运行。DS1302由Vcc1或Vcc2两者中的较大者供电。当Vcc2大于Vcc1＋0.2V时，Vcc2给DS1302供电。当Vcc2小于Vcc1时，DS1302由Vcc1供电。X1和X2是振荡源，外接32.768kHz晶振。RST是复位/片选线，通过把RST输入驱动置高电平来启动所有的数据传送。RST输入有两种功能：首先，RST接通控制逻辑，允许地址/命令序列送入移位寄存器；其次，RST提供终止单字节或多字节数据的传送手段。当RST为高电平时，所有的数据传送被初始化，允许对DS1302进行操作。如果在传送过程中RST置为低电平，则会终止此次数据传送，I/O引脚变为高阻态。上电运行时，在Vcc≥2.5V之前，RST必须保持低电平。只有在SCLK为低电平时，才能将RST置为高电平。I/O为串行数据输入输出端(双向)，SCLK始终是输入端。
     

DS1302的控制字节

DS1302的控制字如下图所示。控制字节的最高有效位(位7)必须是逻辑1，如果它为0，则不能把数据写入DS1302中，位6如果为0，则表示存取日历时钟数据，为1表示存取RAM数据;位5至位1指示操作单元的地址;最低有效位(位0)如为0表示要进行写操作，为1表示进行读操作，控制字节总是从最低位开始输出。

数据输入输出(I/O)

在控制指令字输入后的下一个SCLK时钟的上升沿时，数据被写入DS1302，数据输入从低位即位0开始。同样，在紧跟8位的控制指令字后的下一个SCLK脉冲的下降沿读出DS1302的数据，读出数据时从低位0位到高位7。

DS1302的寄存器

DS1302有12个寄存器，其中有7个寄存器与日历、时钟相关，存放的数据位为BCD码形式,其日历、时间寄存器及其控制字请查阅DS1302的数据手册。

二、电路实现
   如下是本实例中DS1302的电路连接图。由于只是学习DS1302的基本功能，所以本电路没有使用后备电源。

三、 程序设计
下面是DS1302的完整程序,程序实现将一个初始化时间写入DS1302，然后读出DS1302的实时时间，并发送到串口，在计算机上通过串口助手观察程序执行结果。

1. 
   
2. #include<AVR/io.h>        
   
3. #include <util/delay.h>
   
4. #include <avr/interrupt.h>   //中断函数头文件
   
5. //常量声明
   
6. #define BAUD 9600
   
7. #define TURE 1
   
8. #define FALSE 0
   
9. //时钟/日历寄存器
   
10. #define RD    0x01         //读
    
11. #define WR    0x00         //写
    
12. #define SECOND  0x80 //秒
    
13. #define MINUTE  0x82 //分
    
14. #define HOUR  0x84 //时
    
15. #define DAY   0x86 //日
    
16. #define MONTH  0x88 //月
    
17. #define WEEK  0x8A //星期 DATE
    
18. #define YEAR  0x8C //年
    
19. #define WR_PROTECT 0x8E //控制(写保护)
    
20. #define CHARGE     0x90 //涓流充电
    
21. #define BURST  0xBE //时钟多字节
    
22. //配置位
    
23. #define CLK_HALT  0x80 //停止时钟控制位    SECOND bit7
    
24. #define CLK_START  0x00 //启动时钟
    
25. #define M12_24   0x80 //12/24小时值选择位 HOUR  bit7
    
26. #define PROTECT   0x80 //写保护控制位      CONTROL bit7
    
27. #define UPROTECT  0x00 //写保护控制位      CONTROL bit7
    
28. //涓流充电控制常量
    
29. #define TC_D1R2   0xA5 //充电时选择一个二极管和2K电阻  
    
30. #define TC_D2R8   0xAB //充电时选择二个二极管和8K电阻   
    
31. #define TC_DISABLED  0x00 //禁止充电功能
    
32. //RAM 命令
    
33. #define RAMBASE  0xC0 //RAM起始位为0XCO，RAM范围0-31
    
34. //全局变量声明
    
35. unsigned char Get_Time[7] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00};
    
36. 
    
37. //函数声明
    
38. void Delayus(unsigned int lus);         //us延时函数
    
39. void Delayms(unsigned int lms);        //ms延时函数
    
40. void Port_Init(void);   //端口初始化配置
    
41. void Usart_Init(void);  //USART寄存器设置
    
42. void Usart_PutChar(unsigned char cTXData);  //字节发送函数
    
43. void Usart_PutString(unsigned char *pcString); //字符串发送函数
    
44. unsigned char DS1302_ReadByte(void);         //从DS1302读一个字节数据
    
45. void DS1302_WriteByte(unsigned char dat);    //向DS1302写一个字节数据
    
46. unsigned char DS1302_ReadData(unsigned addr); //从DS1302的指定地址读一个字节数据
    
47. void DS1302_WriteData(unsigned char addr,unsigned data);  
    
48.                                                  //向DS1302的指定地址写一个字节数据
    
49. void DS1302_SetTime(unsigned char *time);  //对DS1302设置时间
    
50. void DS1302_GetTime(void);   //从DS1302读取时间
    
51. unsigned char DS1302_Check(void);           //DS1302是否工作检测
    
52. void DS1302_Init(void);                      //DS1302初始化
    
53. int main(void)            
    
54. {
    
55. unsigned char Set_Time[7] = {0x59,0x59,0x10,0x20,0x01,0x02,0x09};
    
56.                                         //设置秒，分，时，日，月，星期，年
    
57. unsigned char i;
    
58. 
    
59. Port_Init();
    
60. Usart_Init();
    
61. 
    
62. Usart_PutString("DS1302实时时钟试验");
    
63. Usart_PutString("设置当前时间为：");
    
64. Usart_PutChar(0x0D);
    
65. Usart_PutChar(0x0A);  //发送回车换行
    
66. Usart_PutChar('2');
    
67. Usart_PutChar('0');
    
68. Usart_PutChar(Set_Time[6] / 16 + 0x30);
    
69. Usart_PutChar(Set_Time[6] % 16 + 0x30);
    
70. Usart_PutString("年");
    
71. Usart_PutChar(' ');
    
72. Usart_PutChar(Set_Time[4] / 16 + 0x30);
    
73. Usart_PutChar(Set_Time[4] % 16 + 0x30);
    
74. Usart_PutString("月");
    
75. Usart_PutChar(' ');
    
76. Usart_PutChar(Set_Time[3] / 16 + 0x30);
    
77. Usart_PutChar(Set_Time[3] % 16 + 0x30);
    
78. Usart_PutString("日");
    
79. Usart_PutChar(' ');
    
80. Usart_PutChar(Set_Time[2] / 16 + 0x30);
    
81. Usart_PutChar(Set_Time[2] % 16 + 0x30);
    
82. Usart_PutString("时");
    
83. Usart_PutChar(' ');
    
84. Usart_PutChar(Set_Time[1] / 16 + 0x30);
    
85. Usart_PutChar(Set_Time[1] % 16 + 0x30);
    
86. Usart_PutString("分");
    
87. Usart_PutChar(' ');
    
88. Usart_PutChar(Set_Time[0] / 16 + 0x30);
    
89. Usart_PutChar(Set_Time[0] % 16 + 0x30);
    
90. Usart_PutString("秒");
    
91. Usart_PutChar(' ');
    
92. Usart_PutString("星期");
    
93. Usart_PutChar(' ');
    
94. //Usart_PutChar(Set_Time[5] / 16 + 0x30);
    
95. Usart_PutChar(Set_Time[5] % 16 + 0x30);
    
96. Usart_PutChar(0x0D);
    
97. Usart_PutChar(0x0A);  //发送回车换行
    
98. 
    
99. DS1302_SetTime(Set_Time);
    
100. 
     
101. 
     
102. sei();          //使能全局中断  
     
103. 
     
104. while(1)
     
105. {
     
106.   DS1302_GetTime();
     
107.   
     
108.   Usart_PutString("现在时间");
     
109.   Usart_PutChar(0x0D);
     
110.   Usart_PutChar(0x0A);  //发送回车换行
     
111.   Usart_PutChar('2');
     
112.   Usart_PutChar('0');
     
113.   Usart_PutChar(Get_Time[6] / 16 + 0x30);
     
114.   Usart_PutChar(Get_Time[6] % 16 + 0x30);
     
115.   Usart_PutString("年");
     
116.   Usart_PutChar(' ');
     
117.   Usart_PutChar(Get_Time[4] / 16 + 0x30);
     
118.   Usart_PutChar(Get_Time[4] % 16 + 0x30);
     
119.   Usart_PutString("月");
     
120.   Usart_PutChar(' ');
     
121.   Usart_PutChar(Get_Time[3] / 16 + 0x30);
     
122.   Usart_PutChar(Get_Time[3] % 16 + 0x30);
     
123.   Usart_PutString("日");
     
124.   Usart_PutChar(' ');
     
125.   Usart_PutChar(Get_Time[2] / 16 + 0x30);
     
126.   Usart_PutChar(Get_Time[2] % 16 + 0x30);
     
127.   Usart_PutString("时");
     
128.   Usart_PutChar(' ');
     
129.   Usart_PutChar(Get_Time[1] / 16 + 0x30);
     
130.   Usart_PutChar(Get_Time[1] % 16 + 0x30);
     
131.   Usart_PutString("分");
     
132.   Usart_PutChar(' ');
     
133.   Usart_PutChar(Get_Time[0] / 16 + 0x30);
     
134.   Usart_PutChar(Get_Time[0] % 16 + 0x30);
     
135.   Usart_PutString("秒");
     
136.   Usart_PutChar(' ');
     
137.   Usart_PutString("星期");
     
138.   Usart_PutChar(' ');
     
139.   
     
140.   //Usart_PutChar(Set_Time[5] / 16 + 0x30);
     
141.   Usart_PutChar(Get_Time[5] % 16 + 0x30);
     
142.   Usart_PutChar(0x0D);
     
143.   Usart_PutChar(0x0A);  //发送回车换行
     
144. 
     
145. for(i = 0;i < 4;i++)
     
146. {
     
147.   Delayms(1000);
     
148. }
     
149. 
     
150. }
     
151. }
     
152. //端口状态初始化设置函数
     
153. void Port_Init()
     
154. {
     
155. PORTD = 0X00;          //USART的发送接收端口分别为PD0和PD1
     
156. DDRD |= (1 << PD3);   //PD0为接收端口，置为输入口；PD1为发送端口，置为输出口
     
157. 
     
158. DDRE |= (1 << PE2) | (1 << PE3) | (1 << PE6); //DS1302的SCLK和I/O引脚设为输出
     
159. //DDRE |= (1 << PE6);                //DS1302的RST引脚设为输出
     
160. }
     
161. //USART寄存器配置函数
     
162. void Usart_Init()
     
163. {
     
164. UCSR1A = 0X00;
     
165. UCSR1C |= (1 << UCSZ11) | (1 << UCSZ10);  //异步，数据格式8，N，1
     
166.       
     
167. UBRR1L = (F_CPU / BAUD / 16 - 1) % 256;    //波特率设置
     
168. UBRR1H = (F_CPU / BAUD / 16 - 1) / 256;  
     
169. UCSR1B |= (1 << RXCIE1) | (1 << RXEN1) | (1 << TXEN1);    //发送使能
     
170. 
     
171. }
     
172. //字节发送函数
     
173. void Usart_PutChar(unsigned char cTXData)
     
174. {
     
175. while( !(UCSR1A & (1 << UDRE1)) );  //只有数据寄存器为空时才能发送数据
     
176. UDR1 = cTXData;                  //发送数据送USART I/O数据寄存器－UDR
     
177. }
     
178. //接收中断函数
     
179. ISR(USART1_RX_vect)
     
180. {
     
181. unsigned char Rev;
     
182. Rev = UDR1;              //从USART I/O数据寄存器－UDR中读出数据
     
183. Usart_PutChar(Rev);    //将接收到的数据发送
     
184. }
     
185. 
     
186. void Usart_PutString(unsigned char *pcString)
     
187. {
     
188. while (*pcString)
     
189. {
     
190.   Usart_PutChar(*pcString++);
     
191. }
     
192. }
     
193. //从DS1302读一个字节数据
     
194. unsigned char DS1302_ReadByte(void)         
     
195. {
     
196. unsigned char i,dat = 0;  //dat存放读出的数据，初始化为0
     
197. PORTE &= ~(1 << PE3);     //DS1302的I/O口上拉不使能，
     
198. DDRE &= ~(1 << PE3);      //DS1302的I/O口设置为输入口，准备读数据
     
199. 
     
200. for(i = 0;i < 8;i++)     //读8位，低位在前，右移
     
201. {
     
202.   dat >>= 1;           //读出的数据右移一位
     
203.   PORTE |= (1 << PE2);  //DS1302的SCLK端口拉高
     
204.   Delayus(10);          //
     
205.   PORTE &= ~(1 << PE2);  //DS1302的SCLK端口拉低，产生下降沿，
     
206.   Delayus(10);
     
207.   if(PINE & (1 << PE3))     //读数据端口状态
     
208.   {
     
209.    dat |= 0x80;          //如果数据端口位高，相应数据位置1
     
210.   }  
     
211. }
     
212. DDRE |= (1 << PE3);   //最后将数据端口设置为输出
     
213.     return dat;     //返回读出的数据
     
214. }
     
215. //向DS1302写一个字节数据
     
216. void DS1302_WriteByte(unsigned char dat)   
     
217. {
     
218. unsigned char i;
     
219. 
     
220. for(i = 0;i < 8;i++)      //写8位，低位在前
     
221. {
     
222.   PORTE &= ~(1 << PE2);  //DS1302的SCLK置低
     
223.   if(dat & 0x01)        //写数据位
     
224.   {
     
225.    PORTE |= (1 << PE3);   //如果该位为1，则I/O口置高
     
226.   }
     
227.   else
     
228.   {
     
229.    PORTE &= ~(1 << PE3);   //如果该位为0，则I/O口置低
     
230.   }
     
231.   Delayus(10);          //
     
232.   PORTE |= (1 << PE2);   //DS1302的SCLK置高，产生上升沿
     
233.   dat >>= 1;               //数据右移1位
     
234. }  
     
235. }
     
236. //从DS1302的指定地址读一个字节数据
     
237. unsigned char DS1302_ReadData(unsigned addr)
     
238. {
     
239. unsigned char data;
     
240. 
     
241. PORTE &= ~(1 << PE6); //拉低片选端
     
242. PORTE &= ~(1 << PE2);//拉低时钟端
     
243. Delayus(10);
     
244. PORTE |= (1 << PE6);//拉高片选端
     
245. Delayus(10);
     
246. DS1302_WriteByte(addr);//写入操作命令（地址）
     
247. Delayus(10);
     
248. data = DS1302_ReadByte();//读出数据
     
249. Delayus(10);
     
250. PORTE &= ~(1 << PE2);  //拉低时钟端
     
251. PORTE &= ~(1 << PE6); //拉低片选端  
     
252. 
     
253. return data;
     
254. }
     
255. //向DS1302的指定地址写一个字节数据
     
256. void DS1302_WriteData(unsigned char addr,unsigned data)  
     
257. {
     
258. PORTE &= ~(1 << PE6); //拉低片选端
     
259. PORTE &= ~(1 << PE2);//拉低时钟端
     
260. Delayus(10);
     
261. PORTE |= (1 << PE6);//拉高片选端
     
262. Delayus(10);
     
263. DS1302_WriteByte(addr);//写入操作命令（地址）
     
264. Delayus(10);
     
265. PORTE &= ~(1 << PE2);//拉低时钟端
     
266. Delayus(10);
     
267. DS1302_WriteByte(data);//写入数据
     
268. PORTE &= ~(1 << PE2);  //拉低时钟端
     
269. Delayus(10);
     
270. PORTE &= ~(1 << PE6); //拉低片选端
     
271. }
     
272. //对DS1302设置时间            
     
273. void DS1302_SetTime(unsigned char *time)  
     
274. {
     
275. unsigned char i;
     
276. unsigned char addr = 0x80;//写入地址从秒寄存器开始
     
277. 
     
278. DS1302_WriteData(WR_PROTECT | WR,UPROTECT);//控制命令,WP位为0,允许写操作
     
279. Delayms(5);
     
280. for(i = 0;i < 7;i++)
     
281. {
     
282.   DS1302_WriteData(addr | WR,time);// 秒 分 时 日 月 星期 年   
     
283.   addr += 2;
     
284.   Delayms(1);
     
285. }
     
286. DS1302_WriteData(WR_PROTECT | WR,PROTECT);//控制命令,WP位为1,不允许写操作   
     
287. }
     
288. //从DS1302读取时间
     
289. void DS1302_GetTime(void)   
     
290. {
     
291. unsigned char i;
     
292. /*
     
293. //
     
294. unsigned char addr;
     
295. PORTA &= ~(1 << PA1);
     
296. for(i = 0;i < 7;i++)
     
297. {
     
298.   tim = DS1302_ReadData(addr | RD);
     
299.   addr += 2;
     
300. }
     
301. */
     
302. 
     
303. ////////////////////
     
304. PORTE &= ~(1 << PE6);
     
305. Delayus(10);
     
306. PORTE |= (1 << PE6);
     
307. Delayus(10);
     
308. DS1302_WriteByte(0xbf);
     
309. for(i = 0;i < 8;i++)
     
310. {
     
311.   Get_Time = DS1302_ReadByte();
     
312. }
     
313. PORTE &= ~(1 << PE6);
     
314. ///////////////////////////////////
     
315. PORTE &= ~(1 << PE2);
     
316. }
     
317. //DS1302是否工作检测
     
318. unsigned char DS1302_Check(void)           
     
319. {
     
320. DS1302_WriteData(WR_PROTECT | WR,UPROTECT);
     
321. DS1302_WriteData(RAMBASE | WR,0x31);
     
322. 
     
323. if(DS1302_ReadData(RAMBASE | WR) == 0x31)
     
324. {
     
325.   return TURE;
     
326. }
     
327. else
     
328. {
     
329.   return FALSE;
     
330. }
     
331. }
     
332. //DS1302初始化
     
333. void DS1302_Init(void)     
     
334. {
     
335. DS1302_WriteData(WR_PROTECT | WR,UPROTECT);   //写入写允许命令
     
336.     DS1302_WriteData(SECOND | WR,CLK_START);      //启动振荡器，DS1302开始工作
     
337. DS1302_WriteData( WR_PROTECT | WR,PROTECT);     //控制命令,WP位为1,不允许写操作   
     
338. }
     
339. 
     
340. //us级别的延时函数
     
341. void Delayus(unsigned int lus)
     
342. {
     
343. while(lus--)
     
344. {
     
345.   _delay_loop_2(4);      //_delay_loop_2(1)是延时4个时钟周期，参数为3则延时12
     
346.              //个时钟周期，本实验用12M晶体，则12个时钟周期为12/12=1us
     
347.     }
     
348. }
     
349. //ms级别的延时函数
     
350. void Delayms(unsigned int lms)
     
351. {
     
352. while(lms--)
     
353. {
     
354.   Delayus(1000);        //延时1ms
     
355.     }
     
356. }
     
357. 
     

复制代码