arduino学习笔记27 - DS1307 RTC时钟芯片与DS18B20数字温度传感器实验

弘毅

本次实验我使用的是购买的一个DS1307 RTC模块，上面集成了一个DS18B20温度传感器，还集成了另外一个存储芯片~~
先上图





再看下硬件连接图，DS1307是I2C接口SCL接模拟5号口，SDA接模拟4号口。DS18B20是单总线模式，他的DS接口接数字2号口。





DS18B20：



DS18x20系列数字温度传感器主要有DS18S20和DS18B20(DS18S20只有9位一种工作模式，分辨率只到0.5摄氏度，DS18B20有9、10、11、12位四种工作可编程控制的模式，分辨率最高为0.0625摄氏度。)，都是由美国Dallas半导体公司(现在改名叫Maxim)生产的。这个系列最大的特点就是采用了Maxim的专利技术1-Wire。顾名思义，1-Wire就是采用单一信号线，但可像I2C，SPI一样，同时传输时钟（clock）又传输数据（data），而且数据传输是双向的。1-Wire 使用较低的数据传输速率，通常是用来沟通小型device，如数位温度计。通过1-Wire技术可以在单一信号线的基础上构成传感器网络，Maxim起名”MicroLan”。

DS18x20的供电主要有两种模式：

Parasite power mode/寄生供电



所谓的寄生供电是指DS18x20只需要两根接线，一根数据线，一根接地线，数据线上还要接一个4.7k上拉电阻连电源，数据线同时也提供了电能。DS18x20内置了电容，高电平期时把电能储存在内部电容里，低电平期内消耗内部电容里的能量工作，直到下次高电平期内再次电容充电。虽然这样的模式简化了线路同时也带来了一些缺陷：

1. 电路的电流一般很小，只有当DS18x20进行温度转化或者写EEPROM时会高达1.5mA，当DS18x20进行上述操作时，数据线必须保持电平拉高状态直到操作结束，期间master端的Arduino不能做任何操作，DS18x20温度转化时这个时间间隔大概是750ms。

2.如果要求DS18x20有精确的转化，数据线在温度转化期间必须保证足够的能量，但当你使用多个DS18x20构成MicroLan进行多点测温时，单靠4.7k的上拉电阻无法提供足够的能量，会导致较大的测温误差。

Normal (external supply) mode/标准(外部供电)



标准外部供电模式，相比寄生供电模式，每个DS18x20需要多一条独立的电源线接独立电源。虽然多用些线，但由于外部供电，保证了每个设备的进精确度和稳定性。而且没有了上述温度转换期间Arduino不能做任何事的问题。

DS18B20的详细介绍就不多讲了，具体可以查看论坛的另一篇帖子http://www.geek-workshop.com/for ... =198&extra=page%3D1

直接进入实战，调用DS18B20，需要使用OneWire库。

把下面代码下载进入arduino控制板。

1. #include <OneWire.h>
   
2. 
   
3. // DS18S20 Temperature chip i/o
   
4. OneWire ds(2);  // on pin 2
   
5. 
   
6. void setup(void) {
   
7.   // initialize inputs/outputs
   
8.   // start serial port
   
9.   Serial.begin(9600);
   
10. }
    
11. 
    
12. void loop(void) {
    
13.   byte i;
    
14.   byte present = 0;
    
15.   byte data[12];
    
16.   byte addr[8];
    
17. 
    
18.   if ( !ds.search(addr)) {
    
19.     Serial.print("No more addresses.\n");
    
20.     ds.reset_search();
    
21.     return;
    
22.   }
    
23. 
    
24.   Serial.print("R=");
    
25.   for( i = 0; i < 8; i++) {
    
26.     Serial.print(addr[i], HEX);
    
27.     Serial.print(" ");
    
28.   }
    
29. 
    
30.   if ( OneWire::crc8( addr, 7) != addr[7]) {
    
31.     Serial.print("CRC is not valid!\n");
    
32.     return;
    
33.   }
    
34. 
    
35.   if ( addr[0] == 0x10) {
    
36.     Serial.print("Device is a DS18S20 family device.\n");
    
37.   }
    
38.   else if ( addr[0] == 0x28) {
    
39.     Serial.print("Device is a DS18B20 family device.\n");
    
40.   }
    
41.   else {
    
42.     Serial.print("Device family is not recognized: 0x");
    
43.     Serial.println(addr[0],HEX);
    
44.     return;
    
45.   }
    
46. 
    
47.   ds.reset();
    
48.   ds.select(addr);
    
49.   ds.write(0x44,1);         // start conversion, with parasite power on at the end
    
50. 
    
51.   delay(1000);     // maybe 750ms is enough, maybe not
    
52.   // we might do a ds.depower() here, but the reset will take care of it.
    
53. 
    
54.   present = ds.reset();
    
55.   ds.select(addr);
    
56.   ds.write(0xBE);         // Read Scratchpad
    
57. 
    
58.   Serial.print("P=");
    
59.   Serial.print(present,HEX);
    
60.   Serial.print(" ");
    
61.   for ( i = 0; i < 9; i++) {           // we need 9 bytes
    
62.     data[i] = ds.read();
    
63.     Serial.print(data[i], HEX);
    
64.     Serial.print(" ");
    
65.   }
    
66.   Serial.print(" CRC=");
    
67.   Serial.print( OneWire::crc8( data, 8), HEX);
    
68.   Serial.println();
    
69. }

复制代码

代码下载好以后打开串口编辑器，然后就会出现下面这样子的画面。



虽然我们读到了Scratchpad的数据，但是显示的是HEX16进制代码，我们还需要转化成我们能读的温度格式。这里推荐一个叫Dallas Temperature Control的Library,大大简化了这个过程。官方地址：http://www.milesburton.com/?titl ... ure_Control_Library

1. #include <OneWire.h>
   
2. #include <DallasTemperature.h>
   
3. 
   
4. // Data wire is plugged into port 2 on the Arduino
   
5. #define ONE_WIRE_BUS 2
   
6. 
   
7. // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
   
8. OneWire oneWire(ONE_WIRE_BUS);
   
9. 
   
10. // Pass our oneWire reference to Dallas Temperature.
    
11. DallasTemperature sensors(&oneWire);
    
12. 
    
13. void setup(void)
    
14. {
    
15.   // start serial port
    
16.   Serial.begin(9600);
    
17.   Serial.println("Dallas Temperature IC Control Library Demo");
    
18. 
    
19.   // Start up the library
    
20.   sensors.begin();
    
21. }
    
22. 
    
23. void loop(void)
    
24. {
    
25.   // call sensors.requestTemperatures() to issue a global temperature
    
26.   // request to all devices on the bus
    
27.   Serial.print("Requesting temperatures...");
    
28.   sensors.requestTemperatures(); // Send the command to get temperatures
    
29.   Serial.println("DONE");
    
30.   
    
31.   Serial.print("Temperature for the device 1 (index 0) is: ");
    
32.   Serial.println(sensors.getTempCByIndex(0));  
    
33. }

复制代码

代码下载好以后，打开串口监视器，就可以看到当前室温了。



下面我们试用一下DS1307时钟芯片功能。
先把下面库自带测试代码下载进入arduino控制板

1. #include <WProgram.h>
   
2. #include <Wire.h>
   
3. #include <DS1307.h>
   
4. 
   
5. int rtc[7];
   
6. int ledPin =  13;
   
7. void setup()
   
8. {
   
9.   DDRC|=_BV(2) |_BV(3);  // POWER:Vcc Gnd
   
10.   PORTC |=_BV(3);  // VCC PINC3
    
11.   pinMode(ledPin, OUTPUT);  
    
12.   Serial.begin(9600);
    
13. 
    
14.   RTC.stop();
    
15.   RTC.set(DS1307_SEC,1);
    
16.   RTC.set(DS1307_MIN,57);
    
17.   RTC.set(DS1307_HR,17);
    
18.   RTC.set(DS1307_DOW,2);
    
19.   RTC.set(DS1307_DATE,18);
    
20.   RTC.set(DS1307_MTH,1);
    
21.   RTC.set(DS1307_YR,10);
    
22.   RTC.start();
    
23. }
    
24. 
    
25. void loop()
    
26. {
    
27.   RTC.get(rtc,true);
    
28. 
    
29.   for(int i=0; i<7; i++)
    
30.   {
    
31.     Serial.print(rtc[i]);
    
32.     Serial.print(" ");
    
33.   }
    
34.   Serial.println();
    
35.         digitalWrite(ledPin, HIGH);
    
36.         delay(500);
    
37.         digitalWrite(ledPin, LOW);
    
38.         delay(500);
    
39. }

复制代码

然后打开串口监视器，就能看到类似下图的样子。


这个模块上还有一个T24C32A EEPROM存储器。。。下面上一个全面一点的代码，对各个期间进行测试。其中刚开始会对I2C器件进行扫描。。。代码不错，大家可以参考下。

1. /**
   
2. * I2CScanner.pde -- I2C bus scanner for Arduino
   
3. *
   
4. * 2009, Tod E. Kurt, [url]http://todbot.com/blog/[/url]
   
5. *
   
6. */
   
7. #include <OneWire.h>
   
8. #include "Wire.h"
   
9. #include <WProgram.h>
   
10. #include <DS1307.h>
    
11. #include <avr/io.h>
    
12. extern "C" {
    
13. #include "utility/twi.h"  // from Wire library, so we can do bus scanning
    
14. }
    
15. 
    
16. 
    
17. byte start_address = 1;
    
18. byte end_address = 127;
    
19. OneWire  ds(2);  // on pin 2
    
20. byte Tdata[12];
    
21. int sensorValue = 0;        // value read from the pot
    
22. int rtc[7];
    
23. float TT=0.0;
    
24. 
    
25. // Scan the I2C bus between addresses from_addr and to_addr.
    
26. // On each address, call the callback function with the address and result.
    
27. // If result==0, address was found, otherwise, address wasn't found
    
28. // (can use result to potentially get other status on the I2C bus, see twi.c)
    
29. // Assumes Wire.begin() has already been called
    
30. void scanI2CBus(byte from_addr, byte to_addr,
    
31.                 void(*callback)(byte address, byte result) )
    
32. {
    
33.   byte rc;
    
34.   byte data = 0; // not used, just an address to feed to twi_writeTo()
    
35.   for( byte addr = from_addr; addr <= to_addr; addr++ ) {
    
36.     rc = twi_writeTo(addr, &data, 0, 1);
    
37.     if(rc==0) callback( addr, rc );
    
38.   }
    
39. }
    
40. 
    
41. // Called when address is found in scanI2CBus()
    
42. // Feel free to change this as needed
    
43. // (like adding I2C comm code to figure out what kind of I2C device is there)
    
44. void scanFunc( byte addr, byte result ) {
    
45.   Serial.print("addr: ");
    
46.   Serial.print(addr,DEC);
    
47.   addr = addr<<1;
    
48.   Serial.print("\t HEX: 0x");
    
49.   Serial.print(addr,HEX);
    
50.   Serial.println( (result==0) ? "\t found!":"   ");
    
51. //  Serial.print( (addr%4) ? "\t":"\n");
    
52. }
    
53. 
    
54. 
    
55.   void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
    
56.     int rdata = data;
    
57.     Wire.beginTransmission(deviceaddress);
    
58.     Wire.send((int)(eeaddress >> 8)); // MSB
    
59.     Wire.send((int)(eeaddress & 0xFF)); // LSB
    
60.     Wire.send(rdata);
    
61.     Wire.endTransmission();
    
62.   }
    
63. 
    
64.   // WARNING: address is a page address, 6-bit end will wrap around
    
65.   // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
    
66.   void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
    
67.     Wire.beginTransmission(deviceaddress);
    
68.     Wire.send((int)(eeaddresspage >> 8)); // MSB
    
69.     Wire.send((int)(eeaddresspage & 0xFF)); // LSB
    
70.     byte c;
    
71.     for ( c = 0; c < length; c++)
    
72.       Wire.send(data[c]);
    
73.     Wire.endTransmission();
    
74.   }
    
75. 
    
76.   byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
    
77.     byte rdata = 0xFF;
    
78.     Wire.beginTransmission(deviceaddress);
    
79.     Wire.send((int)(eeaddress >> 8)); // MSB
    
80.     Wire.send((int)(eeaddress & 0xFF)); // LSB
    
81.     Wire.endTransmission();
    
82.     Wire.requestFrom(deviceaddress,1);
    
83.     if (Wire.available()) rdata = Wire.receive();
    
84.     return rdata;
    
85.   }
    
86. 
    
87.   // maybe let's not read more than 30 or 32 bytes at a time!
    
88.   void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
    
89.     Wire.beginTransmission(deviceaddress);
    
90.     Wire.send((int)(eeaddress >> 8)); // MSB
    
91.     Wire.send((int)(eeaddress & 0xFF)); // LSB
    
92.     Wire.endTransmission();
    
93.     Wire.requestFrom(deviceaddress,length);
    
94.     int c = 0;
    
95.     for ( c = 0; c < length; c++ )
    
96.       if (Wire.available()) buffer[c] = Wire.receive();
    
97.   }
    
98. void DS1302_SetOut(byte data ) {
    
99.     Wire.beginTransmission(B1101000);
    
100.     Wire.send(7); // LSB
     
101.     Wire.send(data);
     
102.     Wire.endTransmission();
     
103. }
     
104. byte DS1302_GetOut(void) {
     
105.     byte rdata = 0xFF;
     
106.     Wire.beginTransmission(B1101000);
     
107.     Wire.send(7); // LSB
     
108.     Wire.endTransmission();
     
109.     Wire.requestFrom(B1101000,1);
     
110.     if (Wire.available()) {
     
111.       rdata = Wire.receive();
     
112.       Serial.println(rdata,HEX);
     
113.     }
     
114.     return rdata;
     
115. }
     
116. void showtime(void){
     
117.   byte i;
     
118.   Serial.print("Time=");
     
119.   DS1302_SetOut(0x00);
     
120.   RTC.get(rtc,true);  
     
121.   for(int i=0; i<7; i++)        {
     
122.   Serial.print(rtc[i]);
     
123.   Serial.print(" ");
     
124.   }
     
125. }
     
126. 
     
127. void readBatVcc(void){
     
128.     sensorValue = analogRead(A1);
     
129.     TT = sensorValue*0.0047;
     
130.     Serial.print("Battery: ");
     
131.     Serial.print(TT);
     
132.     Serial.print("V");
     
133. }
     
134.    
     
135. // standard Arduino setup()
     
136. void setup()
     
137. {
     
138.     DDRC|=_BV(2) |_BV(3);
     
139.     PORTC |=_BV(3);
     
140.     Wire.begin();
     
141. 
     
142.     Serial.begin(19200);
     
143.     Serial.println("--- I2C Bus Scanner Test---");
     
144.     Serial.print("starting scanning of I2C bus from ");
     
145.     Serial.print(start_address,DEC);
     
146.     Serial.print(" to ");
     
147.     Serial.print(end_address,DEC);
     
148.     Serial.println("...");
     
149. 
     
150.     // start the scan, will call "scanFunc()" on result from each address
     
151.     scanI2CBus( start_address, end_address, scanFunc );
     
152. 
     
153.     Serial.println("\n");
     
154.     Serial.println("--- EEPROM Test---");
     
155.     char somedata[] = "this is data from the eeprom"; // data to write
     
156.     i2c_eeprom_write_page(0x50, 0, (byte *)somedata, sizeof(somedata)); // write to EEPROM
     
157.     delay(100); //add a small delay
     
158.     Serial.println("Written Done");   
     
159.     delay(10);
     
160.     Serial.print("Read EERPOM:");
     
161.     byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory
     
162.     int addr=0; //first address
     
163.     while (b!=0)
     
164.     {
     
165.       Serial.print((char)b); //print content to serial port
     
166.       addr++; //increase address
     
167.       b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
     
168.     }
     
169.    Serial.println("\n");
     
170.   Serial.println("");
     
171.   Serial.println("--- DS11307 RTC Test---");  
     
172.   showtime();
     
173.   if(rtc[6]<2011){
     
174.     RTC.stop();
     
175.     RTC.set(DS1307_SEC,1);
     
176.     RTC.set(DS1307_MIN,52);
     
177.     RTC.set(DS1307_HR,16);
     
178.     RTC.set(DS1307_DOW,2);
     
179.     RTC.set(DS1307_DATE,25);
     
180.     RTC.set(DS1307_MTH,1);
     
181.     RTC.set(DS1307_YR,11);
     
182.     RTC.start();
     
183.     Serial.println("SetTime:");
     
184.     showtime();   
     
185.   }
     
186.   
     
187.   Serial.println("\n\n");
     
188.   Serial.println("--- Reserve Power Test---");
     
189.   Serial.println("  Close POWER!:");
     
190.    PORTC &=~_BV(3);
     
191.    byte time;
     
192.    for(time=0;time<5;time++){
     
193.      digitalWrite(13,HIGH);
     
194.      delay(500);
     
195.      digitalWrite(13,LOW);
     
196.      delay(500);     
     
197.      readBatVcc();
     
198.      Serial.println("");
     
199.    }
     
200.     PORTC |=_BV(3);
     
201.    Serial.println("\n  POWER On!");
     
202.       delay(500);
     
203.       showtime();
     
204.       
     
205.     Serial.println("\n");
     
206.     Serial.println("===  Done   ===");
     
207.     Serial.println("\n");
     
208. }
     
209. 
     
210. // standard Arduino loop()
     
211. void loop()
     
212. {
     
213.     byte i;
     
214.     byte present = 0;
     
215.     unsigned int Temper=0;
     
216. 
     
217.    
     
218. readBatVcc();
     
219.    
     
220.     ds.reset();
     
221.     ds.write(0xCC,1);
     
222.     ds.write(0x44,1);         // start conversion, with parasite power on at the end
     
223.     digitalWrite(13,HIGH);
     
224.     delay(450);
     
225.     digitalWrite(13,LOW);
     
226.     delay(450);
     
227.     present = ds.reset();
     
228.     ds.write(0xCC,1);   
     
229.     ds.write(0xBE);         // Read Scratchpad
     
230.     for ( i = 0; i < 9; i++) {           // we need 9 bytes
     
231.       Tdata[i] = ds.read();
     
232.     }   
     
233.     Temper = (Tdata[1]<<8 | Tdata[0]);
     
234.     TT =Temper*0.0625;
     
235.     if(TT>200){
     
236.      Serial.println("\t DS18B20 Not installed!");
     
237.     }else{
     
238.       Serial.print("\t Temperature=");
     
239.       Serial.println(TT);
     
240.     }
     
241.     Serial.println("");
     
242. }

复制代码

然后打开串口监视器，波特率要调节为19200.


附件是这次需要用到的库（适用于0022与0023 IDE）：





补充1.0.1下可用的DS180B20库

hzpyj

本例OneWire的库编译中有点问题，无法通过，需更新为V2.1版本

NaceMichael

谢谢！标记学习！

プ汏坏疍

呵呵，对这比较感兴趣，打算买个回来玩。

プ汏坏疍

激动，今天收到了从淘宝买来的时钟模块了。打算做一个这个出来。嘎嘎。

milkgirl

请教一下，I2C接口SCL接模拟5号口，SDA接模拟4号口。I2C接口是不是指4、5 pin ？求教

弘毅

milkgirl 发表于 2012-1-14 17:51
请教一下，I2C接口SCL接模拟5号口，SDA接模拟4号口。I2C接口是不是指4、5 pin ？求教

I2C口就是A4和A5

milkgirl

谢谢解答～谢谢

河山

请教怎么设定N个温度到一定数值就输出N个信号呢?

MicroCao

在淘宝上看到这个模块了，淘宝上的商品介绍很简单。
1、不知道为什么要在时间模块里加测温模块？
2、所说里面还加了24C56存储模块，这又是为了什么？
总感觉把时间、温度、存储这三种做在同一个模块里看着别扭。

弘毅

MicroCao 发表于 2012-5-2 14:50
在淘宝上看到这个模块了，淘宝上的商品介绍很简单。
1、不知道为什么要在时间模块里加测温模块？
2、所说 ...

额。。。。设计者设计为3合1，其实可以分开的。。。

MicroCao

据卖家的商品介绍，此模块“解决DS1307带备用电池不能读写的问题”，是不是就是模块上加了锂电后，ARDUINO只需要通过A4、A5两条I2C线（不接VCC、GND）就可以读写模块的时间了？
真若这样倒是简化了模块的连接线。

夏异

学习一下了

夏异

我怎么已编译就这么多错误，好像这个库件有问题

弘毅

夏异 发表于 2012-7-13 23:22
我怎么已编译就这么多错误，好像这个库件有问题

这个需要把附件的库全部放进去。当时环境是0022 IDE，1.0下估计会有报错问题。

夏异

弘毅 发表于 2012-7-13 23:29
这个需要把附件的库全部放进去。当时环境是0022 IDE，1.0下估计会有报错问题。

库我已经加进去了，可能是编译环境的缘故