Arduino学习8-连接DS1302时钟模块

DS1302是maxim美信生产的时钟模块，支持年、月、日、时、分、秒、星期显示。支持为后备电池涓流充电。可以。跟Arduino只需要3条数据连接线即可使用。
DS1302电路很简单，如果洞洞板自制的话，可以参考下图：



连线方法：
CE(DS1302 pin5) -> Arduino D5
IO(DS1302 pin6) -> Arduino D6
SCLK(DS1302 pin7) -> Arduino D7
Vcc2(DS1302 pin1) -> Arduino +5v
GND(DS1302 pin4) -> Arduino GND

使用前，先将下面的库文件解压到arduino-0023libraries文件夹下面： DS1302.rar (4.53 KB, 下载次数: 297)

2016-4-14 03:27 上传

点击文件名下载附件

例子代码如下：


/*
Arduino 连接 DS1302
增加了串口调整时间代码
*/
#include <stdio.h>
#include <string.h>
#include <DS1302.h>

/* 接口定义
CE(DS1302 pin5) -> Arduino D5
IO(DS1302 pin6) -> Arduino D6
SCLK(DS1302 pin7) -> Arduino D7
*/
uint8_t CE_PIN   = 5;
uint8_t IO_PIN   = 6;
uint8_t SCLK_PIN = 7;

/* 日期变量缓存 */
char buf[50];
char day[10];
/* 串口数据缓存 */
String comdata = "";
int numdata[7] ={0}, j = 0, mark = 0;
/* 创建 DS1302 对象 */
DS1302 rtc(CE_PIN, IO_PIN, SCLK_PIN);


void print_time()
{
    /* 从 DS1302 获取当前时间 */
    Time t = rtc.time();
    /* 将星期从数字转换为名称 */
    memset(day, 0, sizeof(day));
    switch (t.day)
    {
    case 1: strcpy(day, "Sunday"); break;
    case 2: strcpy(day, "Monday"); break;
    case 3: strcpy(day, "Tuesday"); break;
    case 4: strcpy(day, "Wednesday"); break;
    case 5: strcpy(day, "Thursday"); break;
    case 6: strcpy(day, "Friday"); break;
    case 7: strcpy(day, "Saturday"); break;
    }
    /* 将日期代码格式化凑成buf等待输出 */
    snprintf(buf, sizeof(buf), "%s %04d-%02d-%02d %02d:%02d:%02d", day, t.yr, t.mon, t.date, t.hr, t.min, t.sec);
    /* 输出日期到串口 */
    Serial.println(buf);
}


void setup()
{
    Serial.begin(9600);
    rtc.write_protect(false);
    rtc.halt(false);
}

void loop()
{

    /* 当串口有数据的时候，将数据拼接到变量comdata */
    while (Serial.available() > 0)
    {
        comdata += char(Serial.read());
        delay(2);
        mark = 1;
    }
    /* 以逗号分隔分解comdata的字符串，分解结果变成转换成数字到numdata[]数组 */
    if(mark == 1)
    {
        Serial.print("You inputed : ");
        Serial.println(comdata);
        for(int i = 0; i < comdata.length() ; i++)
        {
            if(comdata[i] == ',' || comdata[i] == 0x10 || comdata[i] == 0x13)
            {
                j++;
            }
            else
            {
                numdata[j] = numdata[j] * 10 + (comdata[i] - '0');
            }
        }
        /* 将转换好的numdata凑成时间格式，写入DS1302 */
        Time t(numdata[0], numdata[1], numdata[2], numdata[3], numdata[4], numdata[5], numdata[6]);
        rtc.time(t);
        mark = 0;j=0;
        /* 清空 comdata 变量，以便等待下一次输入 */
        comdata = String("");
        /* 清空 numdata */
        for(int i = 0; i < 7 ; i++) numdata[i]=0;
    }
   
    /* 打印当前时间 */
    print_time();
    delay(1000);
}
使用方法：

打开Arduino串口调试器即可看到当前时间。如果需要调整时间的话，只需要在串口输入当前日期时间，以逗号分隔

格式为：

年,月,日,时,分,秒,星期

星期数：Sunday=1，MOnday=2，...Saturday=7
比如，今天是2011年11月17日11时23分40秒星期四
填入2011,11,17,11,22,40,5即可





附上1.0 IDE可以使用的库 DS1302 1.0.rar (5.93 KB, 下载次数: 107)

2016-4-14 03:28 上传

点击文件名下载附件


阉割DS1302库，只显示时钟，没有日期。可以减小体积：
DS1302(去掉了年月日部分).rar (3.39 KB, 下载次数: 57)

2016-4-14 03:30 上传

点击文件名下载附件



阉割后库代码如下：

1. /*
   
2. 
   
3.   Version:   1.0  - Aug   6 2010  - initial release
   
4.                          2.0  - Aug  23 2010  - Added functions to use on-chip RAM.
   
5.                          2.1  - Nov  17 2010  - Added setTCR();   
   
6. 
   
7. */
   
8. #include "WProgram.h"
   
9. #include "DS1302.h"
   
10. 
    
11. #define REG_SEC                0
    
12. #define REG_MIN                1
    
13. #define REG_HOUR        2
    
14. #define REG_WP                7
    
15. #define REG_TCR                8
    
16. 
    
17. /* Public */
    
18. 
    
19. Time::Time()
    
20. {
    
21.          
    
22.         this->hour = 0;
    
23.         this->min  = 0;
    
24.         this->sec  = 0;
    
25.         
    
26. }
    
27. 
    
28. DS1302_RAM::DS1302_RAM()
    
29. {
    
30.         for (int i=0; i<31; i++)
    
31.                 cell[i]=0;
    
32. }
    
33. 
    
34. DS1302::DS1302(uint8_t ce_pin, uint8_t data_pin, uint8_t sclk_pin)
    
35. {
    
36.         _ce_pin = ce_pin;
    
37.         _data_pin = data_pin;
    
38.         _sclk_pin = sclk_pin;
    
39. 
    
40.         pinMode(_ce_pin, OUTPUT);
    
41.         pinMode(_sclk_pin, OUTPUT);
    
42. }
    
43. 
    
44. Time DS1302::getTime()
    
45. {
    
46.         Time t;
    
47.         _burstRead();
    
48.         t.sec        = _decode(_burstArray[0]);
    
49.         t.min        = _decode(_burstArray[1]);
    
50.         t.hour        = _decodeH(_burstArray[2]);
    
51.         return t;
    
52. }
    
53. 
    
54. void DS1302::setTime(uint8_t hour, uint8_t min, uint8_t sec)
    
55. {
    
56.         if (((hour>=0) && (hour<24)) && ((min>=0) && (min<60)) && ((sec>=0) && (sec<60)))
    
57.         {
    
58.                 _writeRegister(REG_HOUR, _encode(hour));
    
59.                 _writeRegister(REG_MIN, _encode(min));
    
60.                 _writeRegister(REG_SEC, _encode(sec));
    
61.         }
    
62. }
    
63. 
    
64. 
    
65. 
    
66. char *DS1302::getTimeStr(uint8_t format)
    
67. {
    
68.         char *output= "xxxxxxxx";
    
69.         Time t;
    
70.         t=getTime();
    
71.         if (t.hour<10)
    
72.                 output[0]=48;
    
73.         else
    
74.                 output[0]=char((t.hour / 10)+48);
    
75.         output[1]=char((t.hour % 10)+48);
    
76.         output[2]=58;
    
77.         if (t.min<10)
    
78.                 output[3]=48;
    
79.         else
    
80.                 output[3]=char((t.min / 10)+48);
    
81.         output[4]=char((t.min % 10)+48);
    
82.         output[5]=58;
    
83.         if (format==FORMAT_SHORT)
    
84.                 output[5]=0;
    
85.         else
    
86.         {
    
87.         if (t.sec<10)
    
88.                 output[6]=48;
    
89.         else
    
90.                 output[6]=char((t.sec / 10)+48);
    
91.         output[7]=char((t.sec % 10)+48);
    
92.         output[8]=0;
    
93.         }
    
94.         return output;
    
95. }
    
96. 
    
97. 
    
98. 
    
99. void DS1302::halt(bool enable)
    
100. {
     
101.   uint8_t _reg = _readRegister(REG_SEC);
     
102.   _reg &= ~(1 << 7);
     
103.   _reg |= (enable << 7);
     
104.   _writeRegister(REG_SEC, _reg);
     
105. }
     
106. 
     
107. void DS1302::writeProtect(bool enable)
     
108. {
     
109.   uint8_t _reg = (enable << 7);
     
110.   _writeRegister(REG_WP, _reg);
     
111. }
     
112. 
     
113. void DS1302::setTCR(uint8_t value)
     
114. {
     
115.         _writeRegister(REG_TCR, value);
     
116. }
     
117. 
     
118. /* Private */
     
119. 
     
120. uint8_t DS1302::_readByte()
     
121. {
     
122.         pinMode(_data_pin, INPUT);
     
123. 
     
124.         uint8_t value = 0;
     
125.         uint8_t currentBit = 0;
     
126. 
     
127.         for (int i = 0; i < 8; ++i)
     
128.         {
     
129.                 currentBit = digitalRead(_data_pin);
     
130.                 value |= (currentBit << i);
     
131.                 digitalWrite(_sclk_pin, HIGH);
     
132.                 delayMicroseconds(1);
     
133.                 digitalWrite(_sclk_pin, LOW);
     
134.         }
     
135.         return value;
     
136. }
     
137. 
     
138. void DS1302::_writeByte(uint8_t value)
     
139. {
     
140.         pinMode(_data_pin, OUTPUT);
     
141.         shiftOut(_data_pin, _sclk_pin, LSBFIRST, value);
     
142. }
     
143. 
     
144. uint8_t DS1302::_readRegister(uint8_t reg)
     
145. {
     
146.         uint8_t cmdByte = 129;
     
147.         cmdByte |= (reg << 1);
     
148. 
     
149.         uint8_t readValue;
     
150. 
     
151.         digitalWrite(_sclk_pin, LOW);
     
152.         digitalWrite(_ce_pin, HIGH);
     
153. 
     
154.         _writeByte(cmdByte);
     
155.         readValue = _readByte();
     
156.         
     
157.         digitalWrite(_ce_pin, LOW);
     
158. 
     
159.         return readValue;
     
160. }
     
161. 
     
162. void DS1302::_writeRegister(uint8_t reg, uint8_t value)
     
163. {
     
164.         uint8_t cmdByte = (128 | (reg << 1));
     
165. 
     
166.         digitalWrite(_sclk_pin, LOW);
     
167.         digitalWrite(_ce_pin, HIGH);
     
168. 
     
169.         _writeByte(cmdByte);
     
170.         _writeByte(value);
     
171. 
     
172.         digitalWrite(_ce_pin, LOW);
     
173. }
     
174. 
     
175. void DS1302::_burstRead()
     
176. {
     
177.         digitalWrite(_sclk_pin, LOW);
     
178.         digitalWrite(_ce_pin, HIGH);
     
179. 
     
180.         _writeByte(191);
     
181.         for (int i=0; i<8; i++)
     
182.         {
     
183.                 _burstArray[i] = _readByte();
     
184.         }
     
185.         digitalWrite(_ce_pin, LOW);
     
186. }
     
187. 
     
188. uint8_t        DS1302::_decode(uint8_t value)
     
189. {
     
190.         uint8_t decoded = value & 127;
     
191.         decoded = (decoded & 15) + 10 * ((decoded & (15 << 4)) >> 4);
     
192.         return decoded;
     
193. }
     
194. 
     
195. uint8_t DS1302::_decodeH(uint8_t value)
     
196. {
     
197.   if (value & 128)
     
198.     value = (value & 15) + (12 * ((value & 32) >> 5));
     
199.   else
     
200.     value = (value & 15) + (10 * ((value & 48) >> 4));
     
201.   return value;
     
202. }
     
203. 
     
204. uint8_t        DS1302::_decodeY(uint8_t value)
     
205. {
     
206.         uint8_t decoded = (value & 15) + 10 * ((value & (15 << 4)) >> 4);
     
207.         return decoded;
     
208. }
     
209. 
     
210. uint8_t DS1302::_encode(uint8_t value)
     
211. {
     
212.         uint8_t encoded = ((value / 10) << 4) + (value % 10);
     
213.         return encoded;
     
214. }
     
215. 
     
216. void DS1302::writeBuffer(DS1302_RAM r)
     
217. {
     
218.         digitalWrite(_sclk_pin, LOW);
     
219.         digitalWrite(_ce_pin, HIGH);
     
220. 
     
221.         _writeByte(254);
     
222.         for (int i=0; i<31; i++)
     
223.         {
     
224.                 _writeByte(r.cell[i]);
     
225.         }
     
226.         digitalWrite(_ce_pin, LOW);
     
227. }
     
228. 
     
229. DS1302_RAM DS1302::readBuffer()
     
230. {
     
231.         DS1302_RAM r;
     
232. 
     
233.         digitalWrite(_sclk_pin, LOW);
     
234.         digitalWrite(_ce_pin, HIGH);
     
235. 
     
236.         _writeByte(255);
     
237.         for (int i=0; i<31; i++)
     
238.         {
     
239.                 r.cell[i] = _readByte();
     
240.         }
     
241.         digitalWrite(_ce_pin, LOW);
     
242. 
     
243.         return r;
     
244. }
     
245. 
     
246. void DS1302::poke(uint8_t addr, uint8_t value)
     
247. {
     
248.         if ((addr >=0) && (addr<=30))
     
249.         {
     
250.                 addr = (addr * 2) + 192;
     
251. 
     
252.                 digitalWrite(_sclk_pin, LOW);
     
253.                 digitalWrite(_ce_pin, HIGH);
     
254. 
     
255.                 _writeByte(addr);
     
256.                 _writeByte(value);
     
257. 
     
258.                 digitalWrite(_ce_pin, LOW);
     
259.         }
     
260. }
     
261. 
     
262. uint8_t DS1302::peek(uint8_t addr)
     
263. {
     
264.         if ((addr >=0) && (addr<=30))
     
265.         {
     
266.                 addr = (addr * 2) + 193;
     
267. 
     
268.                 uint8_t readValue;
     
269. 
     
270.                 digitalWrite(_sclk_pin, LOW);
     
271.                 digitalWrite(_ce_pin, HIGH);
     
272. 
     
273.                 _writeByte(addr);
     
274.                 readValue = _readByte();
     
275.                
     
276.                 digitalWrite(_ce_pin, LOW);
     
277. 
     
278.                 return readValue;
     
279.         }
     
280.         else
     
281.                 return 0;
     
282. }
     

复制代码

程序中午抽空已经写完先发个图给大家欣赏一下 再次谢谢 弘毅 大哥给的库  晚些时候整理一下吧程序和图纸发上来。


直接发代码好了，硬件连接已经写在里面了数码管是用595驱动的6级串联。

1.     /*Arduino 连接 DS1302
   
2.     增加了串口调整时间代码*/
   
3.     #include <stdio.h>
   
4.     #include <string.h>
   
5.     #include <DS1302.h>
   
6.     /* 接口定义
   
7.     CE(DS1302 pin5) -> Arduino D5
   
8.     IO(DS1302 pin6) -> Arduino D6
   
9.     SCLK(DS1302 pin7) -> Arduino D7*/
   
10.     uint8_t CE_PIN   = 5;
    
11.     uint8_t IO_PIN   = 6;
    
12.     uint8_t SCLK_PIN = 7;
    
13.     /**************************************************************
    
14.     GND(pin 8) to ground,
    
15.     VCC(pin 16) to 5V
    
16.     OE (pin 13) to ground
    
17.     MR (pin 10) to 5V
    
18.     latchPin = 13; to 595 pin 12
    
19.     clockPin = 12; to 595 pin 11
    
20.     dataPin = 11;  to 595 pin 14
    
21.     ****************************************************************/
    
22.     char latchPin = 13;//Pin connected to ST_CP of 74HC595
    
23.     char clockPin = 12;//Pin connected to SH_CP of 74HC595
    
24.     char dataPin = 11;//Pin connected to DS of 74HC595
    
25.     int FIR,SEC,THI,FOR,FIF,SIX;
    
26.     ///////////////////0////1///2////3/////4////5////6/////7////8///9////
    
27.     byte segcode[10]={0X40,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X00,0X10};
    
28.     /* 日期变量缓存 */
    
29.     char buf[50];
    
30.     char day[10];
    
31.     /* 串口数据缓存 */
    
32.     String comdata = "";
    
33.     int numdata[7] ={0}, j = 0, mark = 0;
    
34.     /* 创建 DS1302 对象 */
    
35.     DS1302 rtc(CE_PIN, IO_PIN, SCLK_PIN);
    
36. 
    
37. 
    
38.     void print_time()
    
39.     {
    
40.         /* 从 DS1302 获取当前时间 */
    
41.         Time t = rtc.time();
    
42.         /* 将星期从数字转换为名称 */
    
43.         memset(day, 0, sizeof(day));
    
44.         switch (t.day)
    
45.         {
    
46.         case 1: strcpy(day, "Sunday"); break;
    
47.         case 2: strcpy(day, "Monday"); break;
    
48.         case 3: strcpy(day, "Tuesday"); break;
    
49.         case 4: strcpy(day, "Wednesday"); break;
    
50.         case 5: strcpy(day, "Thursday"); break;
    
51.         case 6: strcpy(day, "Friday"); break;
    
52.         case 7: strcpy(day, "Saturday"); break;
    
53.         }
    
54.         FIR = t.hr/10;
    
55.         SEC = t.hr%10;
    
56.         THI = t.min/10;
    
57.         FOR = t.min%10;
    
58.         FIF = t.sec/10;
    
59.         SIX = t.sec%10;
    
60.         /* 将日期代码格式化凑成buf等待输出 */
    
61.         snprintf(buf, sizeof(buf), "%s %04d-%02d-%02d %02d:%02d:%02d", day, t.yr, t.mon, t.date, t.hr, t.min, t.sec);
    
62.         /* 输出日期到串口 */
    
63.         Serial.println(buf);
    
64.     }
    
65.     void setup()
    
66.     {
    
67.         pinMode(latchPin, OUTPUT);
    
68.         pinMode(clockPin, OUTPUT);
    
69.         pinMode(dataPin, OUTPUT);
    
70.         Serial.begin(9600);
    
71.         rtc.write_protect(false);
    
72.         rtc.halt(false);
    
73.     }
    
74.     void loop()
    
75.     {
    
76.         /* 当串口有数据的时候，将数据拼接到变量comdata */
    
77.         while (Serial.available() > 0)
    
78.         {
    
79.             comdata += char(Serial.read());
    
80.             delay(2);
    
81.             mark = 1;
    
82.         }
    
83.         /* 以逗号分隔分解comdata的字符串，分解结果变成转换成数字到numdata[]数组 */
    
84.         if(mark == 1)
    
85.         {
    
86.             Serial.print("You inputed : ");
    
87.             Serial.println(comdata);
    
88.             for(int i = 0; i < comdata.length() ; i++)
    
89.             {
    
90.                 if(comdata[i] == ',' || comdata[i] == 0x10 || comdata[i] == 0x13)
    
91.                 {
    
92.                     j++;
    
93.                 }
    
94.                 else
    
95.                 {
    
96.                     numdata[j] = numdata[j] * 10 + (comdata[i] - '0');
    
97.                 }
    
98.             }
    
99.             /* 将转换好的numdata凑成时间格式，写入DS1302 */
    
100.             Time t(numdata[0], numdata[1], numdata[2], numdata[3], numdata[4], numdata[5], numdata[6]);
     
101.             rtc.time(t);
     
102.             mark = 0;j=0;
     
103.             /* 清空 comdata 变量，以便等待下一次输入 */
     
104.             comdata = String("");
     
105.             /* 清空 numdata */
     
106.             for(int i = 0; i < 7 ; i++) numdata[i]=0;
     
107.         }  
     
108.               digitalWrite(latchPin, LOW);
     
109.               shiftOut(dataPin, clockPin, MSBFIRST,segcode[FIR]);
     
110.               shiftOut(dataPin, clockPin, MSBFIRST,segcode[SEC]);
     
111.               shiftOut(dataPin, clockPin, MSBFIRST,segcode[THI]);
     
112.               shiftOut(dataPin, clockPin, MSBFIRST,segcode[FOR]);
     
113.               shiftOut(dataPin, clockPin, MSBFIRST,segcode[FIF]);
     
114.               shiftOut(dataPin, clockPin, MSBFIRST,segcode[SIX]);
     
115.               digitalWrite(latchPin, HIGH);
     
116.         /* 打印当前时间 */
     
117.         print_time();
     
118.         delay(1000);//refresh time
     
119.     }

复制代码

我的也安装楼主的方法搞定了 ，说一下 关于时间乱跳和改不了时间的问题，
首先，我的晶振是从废旧电脑主板上拆下来的，所以肯定不会有 不是6pf 的问题吧 ；
其次，我的线太长，没办法，自己焊接的模块接口是针式的  ，arduino uno R3上都是插座，没有一头针一头座的排线吧，开始是用两根线接在一起转换的，最后找了几个插针直接插在uno 的插座上转换的，取消一根线；先换了三根数据线（5、6、7），还是不能修改时间，不过时间显示已经稳定了，有戏。最后将电源线也改过来，一切OK。

哈哈......我做了个LCD时钟带温度显示、星期显示。晒下代码：先发下3个库文件：

DallasTemperature.rar (16.4 KB, 下载次数: 39)

2016-4-14 03:48 上传

点击文件名下载附件

DS1302.rar (5.92 KB, 下载次数: 42)

2016-4-14 03:48 上传

点击文件名下载附件

LiquidCrystal_I2C1602V1.rar (31.16 KB, 下载次数: 31)

2016-4-14 03:48 上传

点击文件名下载附件

1.     #include <Wire.h>
   
2.     #include <OneWire.h>
   
3.     #include <DallasTemperature.h>
   
4.     #include <LiquidCrystal_I2C.h>
   
5. 
   
6.     #include <stdio.h>
   
7.     #include <string.h>
   
8.     #include <DS1302.h>
   
9. 
   
10.     int Mode=0;
    
11.     int h = 0;
    
12.     int m = 0;
    
13.     int s = 0;
    
14.     int d = 12;
    
15.     int mo = 5;
    
16.     int y = 15;
    
17.     uint8_t CE_PIN   = 5;
    
18.     uint8_t IO_PIN   = 6;
    
19.     uint8_t SCLK_PIN = 7;
    
20.     float c = 0.00;
    
21.     String comdata = "";
    
22.     int numdata[7] ={0}, j = 0, mark = 0;
    
23.     char day[10];
    
24. 
    
25. 
    
26.     byte one[8] = {
    
27.       B00000,
    
28.       B00000,
    
29.       B00000,
    
30.       B11111,
    
31.       B00000,
    
32.       B00000,
    
33.       B00000,
    
34.       B00000,
    
35.     };
    
36. 
    
37.     byte two[8] = {
    
38.       B00000,
    
39.       B01110,
    
40.       B00000,
    
41.       B00000,
    
42.       B00000,
    
43.       B11111,
    
44.       B00000,
    
45.       B00000,
    
46.     };
    
47. 
    
48.     byte three [8] = {
    
49.       B00000,
    
50.       B01110,
    
51.       B00000,
    
52.       B01110,
    
53.       B00000,
    
54.       B11111,
    
55.       B00000,
    
56.       B00000,
    
57.     };
    
58. 
    
59.     byte four[8] = {
    
60.       B00000,
    
61.       B11111,
    
62.       B10001,
    
63.       B10101,
    
64.       B11101,
    
65.       B00001,
    
66.       B01110,
    
67.       B00000,
    
68.     };
    
69. 
    
70. 
    
71.     byte five [8] = {
    
72.       B00000,
    
73.       B11110,
    
74.       B01000,
    
75.       B11110,
    
76.       B01010,
    
77.       B01010,
    
78.       B11111,
    
79.       B00000,
    
80.     };
    
81. 
    
82.     byte six[8] = {
    
83.       B00000,
    
84.       B00100,
    
85.       B00000,
    
86.       B11111,
    
87.       B00000,
    
88.       B01010,
    
89.       B10001,
    
90.       B00000,
    
91.     };
    
92. 
    
93.     byte seven [8] = {
    
94.       B11111,
    
95.       B10001,
    
96.       B10001,
    
97.       B11111,
    
98.       B10001,
    
99.       B10001,
    
100.       B11111,
     
101.       B00000,
     
102.     };
     
103. 
     
104. 
     
105.     LiquidCrystal_I2C lcd(0x27, 16, 2);
     
106.     DS1302 rtc(CE_PIN, IO_PIN, SCLK_PIN);
     
107.     #define ONE_WIRE_BUS 2
     
108.     OneWire oneWire(ONE_WIRE_BUS);
     
109.     DallasTemperature sensors(&oneWire);
     
110. 
     
111. 
     
112. 
     
113.     void setup() {
     
114.       sensors.begin();
     
115.       lcd.init();
     
116.       lcd.backlight();
     
117.       lcd.createChar(0, one);
     
118.       lcd.createChar(1, two);
     
119.       lcd.createChar(2, three);
     
120.       lcd.createChar(3, four);
     
121.       lcd.createChar(4, five);
     
122.       lcd.createChar(5, six);
     
123.       lcd.createChar(6, seven);
     
124.       lcd.home();
     
125.       lcd.print("Welcome to use!");
     
126.       delay(1000);
     
127.       lcd.clear();
     
128.       Serial.begin(9600);
     
129.       Serial.println("Wait for set time");
     
130.       rtc.write_protect(false);
     
131.         rtc.halt(false);
     
132.     }
     
133. 
     
134. 
     
135.       
     
136. 
     
137.     void Display(){
     
138.       Time t = rtc.time();
     
139.       memset(day, 0, sizeof(day));
     
140.         switch (t.day)
     
141.         {
     
142.         case 1: lcd.setCursor(12,1); lcd.write((byte)0); break;
     
143.         case 2: lcd.setCursor(12,1); lcd.write(1); break;
     
144.         case 3: lcd.setCursor(12,1); lcd.write(2); break;
     
145.         case 4: lcd.setCursor(12,1); lcd.write(3); break;
     
146.         case 5: lcd.setCursor(12,1); lcd.write(4); break;
     
147.         case 6: lcd.setCursor(12,1); lcd.write(5); break;
     
148.         case 7: lcd.setCursor(12,1); lcd.write(6); break;
     
149.         }
     
150.       lcd.setCursor(0,0);
     
151.       if(t.hr < 10)  lcd.print("0");
     
152.       lcd.print(t.hr);
     
153.       lcd.print(":");
     
154.       if(t.min < 10)  lcd.print("0");
     
155.       lcd.print(t.min);
     
156.       lcd.print(":");
     
157.       if(t.sec < 10)  lcd.print("0");
     
158.       lcd.print(t.sec);
     
159.       lcd.setCursor(0,1);
     
160.       lcd.print(t.yr);
     
161.       lcd.print("/");
     
162.       if(t.mon < 10)  lcd.print("0");
     
163.       lcd.print(t.mon);
     
164.       lcd.print("/");
     
165.       if(t.date < 10)  lcd.print("0");
     
166.       lcd.print(t.date);
     
167.       lcd.setCursor(9,0);
     
168.       lcd.print(c);
     
169.       lcd.write((char)223);
     
170.       lcd.print("C");
     
171.       lcd.print("     ");
     
172.     }
     
173. 
     
174. 
     
175.     void loop() {
     
176.       sensors.requestTemperatures();
     
177.       c = sensors.getTempCByIndex(12);
     
178.       Display();
     
179.       /* 当串口有数据的时候，将数据拼接到变量comdata */
     
180.         while (Serial.available() > 0)
     
181.         {
     
182.             comdata += char(Serial.read());
     
183.             delay(2);
     
184.             mark = 1;
     
185.         }
     
186.         /* 以逗号分隔分解comdata的字符串，分解结果变成转换成数字到numdata[]数组 */
     
187.         if(mark == 1)
     
188.         {
     
189.             Serial.print("You inputed : ");
     
190.             Serial.println(comdata);
     
191.             for(int i = 0; i < comdata.length() ; i++)
     
192.             {
     
193.                 if(comdata[i] == ',' || comdata[i] == 0x10 || comdata[i] == 0x13)
     
194.                 {
     
195.                     j++;
     
196.                 }
     
197.                 else
     
198.                 {
     
199.                     numdata[j] = numdata[j] * 10 + (comdata[i] - '0');
     
200.                 }
     
201.             }
     
202.             /* 将转换好的numdata凑成时间格式，写入DS1302 */
     
203.             Time t(numdata[0], numdata[1], numdata[2], numdata[3], numdata[4], numdata[5], numdata[6]);
     
204.             rtc.time(t);
     
205.             mark = 0;j=0;
     
206.             /* 清空 comdata 变量，以便等待下一次输入 */
     
207.             comdata = String("");
     
208.             /* 清空 numdata */
     
209.             for(int i = 0; i < 7 ; i++) numdata[i]=0;
     
210.         }
     
211.     }
     
212. 
     
213. 复制代码
     
214. 注意，设置法有点不一样。如：2015年10月17日10时18分0秒星期天，
     
215. 输入：2015,10,17,10,18,0,7即可。
     
216. 
     
217. 用LCD1602不带I2C模块的，代码如下：
     
218. 
     
219.     #include <OneWire.h>
     
220.     #include <DallasTemperature.h>
     
221.     #include <LiquidCrystal.h>
     
222. 
     
223.     #include <stdio.h>
     
224.     #include <string.h>
     
225.     #include <DS1302.h>
     
226. 
     
227.     int Mode=0;
     
228.     int h = 0;
     
229.     int m = 0;
     
230.     int s = 0;
     
231.     int d = 12;
     
232.     int mo = 5;
     
233.     int y = 15;
     
234.     uint8_t CE_PIN   = 5;
     
235.     uint8_t IO_PIN   = 6;
     
236.     uint8_t SCLK_PIN = 7;
     
237.     float c = 0.00;
     
238.     String comdata = "";
     
239.     int numdata[7] ={0}, j = 0, mark = 0;
     
240.     char day[10];
     
241. 
     
242. 
     
243.     byte one[8] = {
     
244.       B00000,
     
245.       B00000,
     
246.       B00000,
     
247.       B11111,
     
248.       B00000,
     
249.       B00000,
     
250.       B00000,
     
251.       B00000,
     
252.     };
     
253. 
     
254.     byte two[8] = {
     
255.       B00000,
     
256.       B01110,
     
257.       B00000,
     
258.       B00000,
     
259.       B00000,
     
260.       B11111,
     
261.       B00000,
     
262.       B00000,
     
263.     };
     
264. 
     
265.     byte three [8] = {
     
266.       B00000,
     
267.       B01110,
     
268.       B00000,
     
269.       B01110,
     
270.       B00000,
     
271.       B11111,
     
272.       B00000,
     
273.       B00000,
     
274.     };
     
275. 
     
276.     byte four[8] = {
     
277.       B00000,
     
278.       B11111,
     
279.       B10001,
     
280.       B10101,
     
281.       B11101,
     
282.       B00001,
     
283.       B01110,
     
284.       B00000,
     
285.     };
     
286. 
     
287. 
     
288.     byte five [8] = {
     
289.       B00000,
     
290.       B11110,
     
291.       B01000,
     
292.       B11110,
     
293.       B01010,
     
294.       B01010,
     
295.       B11111,
     
296.       B00000,
     
297.     };
     
298. 
     
299.     byte six[8] = {
     
300.       B00000,
     
301.       B00100,
     
302.       B00000,
     
303.       B11111,
     
304.       B00000,
     
305.       B01010,
     
306.       B10001,
     
307.       B00000,
     
308.     };
     
309. 
     
310.     byte seven [8] = {
     
311.       B11111,
     
312.       B10001,
     
313.       B10001,
     
314.       B11111,
     
315.       B10001,
     
316.       B10001,
     
317.       B11111,
     
318.       B00000,
     
319.     };
     
320. 
     
321. 
     
322.     LiquidCrystal_I2C lcd(3,4,5,6,7,8);
     
323.     DS1302 rtc(CE_PIN, IO_PIN, SCLK_PIN);
     
324.     #define ONE_WIRE_BUS 2
     
325.     OneWire oneWire(ONE_WIRE_BUS);
     
326.     DallasTemperature sensors(&oneWire);
     
327. 
     
328. 
     
329. 
     
330.     void setup() {
     
331.       sensors.begin();
     
332.       lcd.init();
     
333.       lcd.backlight();
     
334.       lcd.createChar(0, one);
     
335.       lcd.createChar(1, two);
     
336.       lcd.createChar(2, three);
     
337.       lcd.createChar(3, four);
     
338.       lcd.createChar(4, five);
     
339.       lcd.createChar(5, six);
     
340.       lcd.createChar(6, seven);
     
341.       lcd.home();
     
342.       lcd.print("Welcome to use!");
     
343.       delay(1000);
     
344.       lcd.clear();
     
345.       Serial.begin(9600);
     
346.       Serial.println("Wait for set time");
     
347.       rtc.write_protect(false);
     
348.         rtc.halt(false);
     
349.     }
     
350. 
     
351. 
     
352.       
     
353. 
     
354.     void Display(){
     
355.       Time t = rtc.time();
     
356.       memset(day, 0, sizeof(day));
     
357.         switch (t.day)
     
358.         {
     
359.         case 1: lcd.setCursor(12,1); lcd.write((byte)0); break;
     
360.         case 2: lcd.setCursor(12,1); lcd.write(1); break;
     
361.         case 3: lcd.setCursor(12,1); lcd.write(2); break;
     
362.         case 4: lcd.setCursor(12,1); lcd.write(3); break;
     
363.         case 5: lcd.setCursor(12,1); lcd.write(4); break;
     
364.         case 6: lcd.setCursor(12,1); lcd.write(5); break;
     
365.         case 7: lcd.setCursor(12,1); lcd.write(6); break;
     
366.         }
     
367.       lcd.setCursor(0,0);
     
368.       if(t.hr < 10)  lcd.print("0");
     
369.       lcd.print(t.hr);
     
370.       lcd.print(":");
     
371.       if(t.min < 10)  lcd.print("0");
     
372.       lcd.print(t.min);
     
373.       lcd.print(":");
     
374.       if(t.sec < 10)  lcd.print("0");
     
375.       lcd.print(t.sec);
     
376.       lcd.setCursor(0,1);
     
377.       lcd.print(t.yr);
     
378.       lcd.print("/");
     
379.       if(t.mon < 10)  lcd.print("0");
     
380.       lcd.print(t.mon);
     
381.       lcd.print("/");
     
382.       if(t.date < 10)  lcd.print("0");
     
383.       lcd.print(t.date);
     
384.       lcd.setCursor(9,0);
     
385.       lcd.print(c);
     
386.       lcd.write((char)223);
     
387.       lcd.print("C");
     
388.       lcd.print("     ");
     
389.     }
     
390. 
     
391. 
     
392.     void loop() {
     
393.       sensors.requestTemperatures();
     
394.       c = sensors.getTempCByIndex(12);
     
395.       Display();
     
396.       /* 当串口有数据的时候，将数据拼接到变量comdata */
     
397.         while (Serial.available() > 0)
     
398.         {
     
399.             comdata += char(Serial.read());
     
400.             delay(2);
     
401.             mark = 1;
     
402.         }
     
403.         /* 以逗号分隔分解comdata的字符串，分解结果变成转换成数字到numdata[]数组 */
     
404.         if(mark == 1)
     
405.         {
     
406.             Serial.print("You inputed : ");
     
407.             Serial.println(comdata);
     
408.             for(int i = 0; i < comdata.length() ; i++)
     
409.             {
     
410.                 if(comdata[i] == ',' || comdata[i] == 0x10 || comdata[i] == 0x13)
     
411.                 {
     
412.                     j++;
     
413.                 }
     
414.                 else
     
415.                 {
     
416.                     numdata[j] = numdata[j] * 10 + (comdata[i] - '0');
     
417.                 }
     
418.             }
     
419.             /* 将转换好的numdata凑成时间格式，写入DS1302 */
     
420.             Time t(numdata[0], numdata[1], numdata[2], numdata[3], numdata[4], numdata[5], numdata[6]);
     
421.             rtc.time(t);
     
422.             mark = 0;j=0;
     
423.             /* 清空 comdata 变量，以便等待下一次输入 */
     
424.             comdata = String("");
     
425.             /* 清空 numdata */
     
426.             for(int i = 0; i < 7 ; i++) numdata[i]=0;
     
427.         }
     
428.     }

复制代码

在arduino IDE 1.0 及后续版本，WProgram.h已经改名为 Arduino.h，你把相应的.h和.cpp改名就行。
就是说 把 D:\用户目录\我的文档\00\libraries\DS1302/ 用文本编辑器打开 DS1302.cpp和DS1302.h文件，将文件中有 WProgram.h已经改名为 Arduino.h，就OK了！
这是在1.0.X版里编译更老的程序时的通病，一个更完美的解决方案是，在老的程序前加这几行就新老IDE通吃：

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

淘宝上买的DS1302带电池的模块，用面包板搭建的电路，开始也出现秒信号乱跳，年份不可设置，不能修改时间的情况。后将模块信号引脚紧贴Nano管脚，电源使用3.3V，问题都解决了。信号线长了，干扰了。

好东东一定要顶一下!

谢谢分享

谢谢分享，分享代码

很不错，正好用到，谢谢

非常好

非常不错，棒棒棒

51黑学者 发表于 2016-4-14 03:51
淘宝上买的DS1302带电池的模块，用面包板搭建的电路，开始也出现秒信号乱跳，年份不可设置，不能 ...

最近在做一个项目，能把这程序源码给我吗，能指导我吗？可以的话可以加我QQ号：956582782  邮箱956582782@qq.com

很不错，正好用到，谢谢

非常不错，棒棒棒

学习了

谢谢分享！

谢谢分享 楼主辛苦了

如何用oled显示呢，楼主厉害

感谢楼主分享！

为什么下载都的需要B啊

为什么显示不对呢，一直显示2165-85-85........而且不能修改时间

初学者，学习学习，不错

s试了一下，分秒乱跳 不准确呀

问一下stdio.h是什么文件

问一下stdio.h是什么文件

谢谢分享

51黑学者 发表于 2016-4-14 03:51
淘宝上买的DS1302带电池的模块，用面包板搭建的电路，开始也出现秒信号乱跳，年份不可设置，不能 ...

找不到12864的例子，楼主有例子吗？求例子程序

我按照上图的方法试了，不能修改时间，是什么问题

我也遇到了这种情况，用了好多种方法都不能正确设定时间。不过我发现设置2009年的日期还行，可就是不能设置2017年的日期，怀疑是模块的问题。

多谢楼主分享。

我的能设置2017  就是设置不了10月   设置10月 就显示9月

可以下载吗

求库文件

初学者，学习学习，不错

我这始终不能显示正常日期

李xx 发表于 2017-4-16 14:28
问一下stdio.h是什么文件

stdio.h是C的标准库文件，standard input & output.

厉害，学习了

请问我另外一个1302的库为什么编译失败了？

之前ds1302会断电不走时不知道什么操作