logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

arduino学习笔记27

 开启美好每一天 2014-01-14

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

IMGP5813_调整大小.JPG 

IMGP5818_调整大小.JPG 

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

DS1307_Module.jpg 

IMGP5820_调整大小.JPG 

DS18B20：

IMGP6090_调整大小.JPG 

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/寄生供电

schematic-dallas-18s20.gif 

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

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

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

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

normal_mode.png 

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


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

2011-11-18 10-37-49.jpg 

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

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

2011-11-18 23-32-12.jpg 

下面我们试用一下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. } 


 然后打开串口监视器，就能看到类似下图的样子。
2011-11-20 20-15-49.jpg 

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

 

  1. /** 
  2.  * I2CScanner.pde -- I2C bus scanner for Arduino 
  3.  * 
  4.  * 2009, Tod E. Kurt, [url]http:///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.
2011-11-20 20-20-35.jpg 

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 开启美好每一天 > 《Arduino》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多