// ********************************************************************************************************** // WeatherNode2 (DS18B20 sensor) sameple sketch that works with Moteinos equipped with RFM69W/RFM69HW // It sends periodic readings (temp) from Moteino to the base node Moteino // For use with MoteinoMEGA you will have to revisit the pin definitions defined below // ********************************************************************************** // Copyright Felix Rusu 2017, http://www.LowPowerLab.com/contact, changed by Luka // ********************************************************************************** // License // ********************************************************************************** // This program is free software; you can redistribute it // and/or modify it under the terms of the GNU General // Public License as published by the Free Software // Foundation; either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will // be useful, but WITHOUT ANY WARRANTY; without even the // implied warranty of MERCHANTABILITY or FITNESS FOR A // PARTICULAR PURPOSE. See the GNU General Public // License for more details. // // Licence can be viewed at // http://www.gnu.org/licenses/gpl-3.0.txt // // Please maintain this license information along with authorship // and copyright notices in any redistribution of this code // ********************************************************************************** #include //get it here: https://github.com/lowpowerlab/rfm69 #include //get it here: https://github.com/lowpowerlab/rfm69 #include //get it here: https://github.com/lowpowerlab/rfm69 #include //get it here: https://github.com/lowpowerlab/spiflash #include //included in Arduino IDE (www.arduino.cc) #include // download in Arduino IDE #include //get it here: https://github.com/lowpowerlab/lowpower //writeup here: http://www.rocketscream.com/blog/2011/07/04/lightweight-low-power-arduino-library/ //********************************************************************************************* //************ IMPORTANT SETTINGS - YOU MUST CHANGE/CONFIGURE TO FIT YOUR HARDWARE ************ //********************************************************************************************* #define GATEWAYID 1 #define NODEID 40 #define NETWORKID 100 //#define FREQUENCY RF69_433MHZ //#define FREQUENCY RF69_868MHZ #define FREQUENCY RF69_915MHZ //Match this with the version of your Moteino! (others: RF69_433MHZ, RF69_868MHZ) #define ENCRYPTKEY "sampleEncryptKey" //has to be same 16 characters/bytes on all nodes, not more not less! #define IS_RFM69HW //uncomment only for RFM69HW! Leave out if you have RFM69W! //***************************************************************************************************************** #define ENABLE_ATC //comment out this line to disable AUTO TRANSMISSION CONTROL #define ATC_RSSI -75 //***************************************************************************************************************** #define SEND_LOOPS 1 //send data this many sleep loops (15 loops of 8sec cycles = 120sec ~ 2 minutes) #define SLEEP_FASTEST SLEEP_15MS #define SLEEP_FAST SLEEP_250MS #define SLEEP_SEC SLEEP_1S #define SLEEP_LONG SLEEP_2S #define SLEEP_LONGER SLEEP_4S #define SLEEP_LONGEST SLEEP_8S period_t sleepTime = SLEEP_8S; //period_t is an enum type defined in the LowPower library (LowPower.h) //***************************************************************************************************************** #ifdef __AVR_ATmega1284P__ #define LED 15 // Moteino MEGAs have LEDs on D15 #define FLASH_SS 23 // and FLASH SS on D23 #else #define LED 9 // Moteinos have LEDs on D9 #define FLASH_SS 8 // and FLASH SS on D8 #endif //#define BLINK_EN //uncomment to blink LED on every send //#define SERIAL_EN //comment out if you don't want any serial output #ifdef SERIAL_EN #define SERIAL_BAUD 115200 #define DEBUG(input) {Serial.print(input);} #define DEBUGln(input) {Serial.println(input);} #define SERIALFLUSH() {Serial.flush();} #else #define DEBUG(input); #define DEBUGln(input); #define SERIALFLUSH(); #endif //********************************************************************************************************************* #ifdef ENABLE_ATC RFM69_ATC radio; #else RFM69 radio; #endif SPIFlash flash(FLASH_SS, 0x2020); //Mircon M25P40 4MBIT flash chip on CS pin D8 (default for Moteino) char Cstr[10]; char buffer[50]; OneWire myds(3); byte readstage; byte resolution; unsigned long starttime; unsigned long elapsedtime; byte dsaddr[8]; void setup(void) { #ifdef SERIAL_EN Serial.begin(SERIAL_BAUD); #endif pinMode(LED, OUTPUT); radio.initialize(FREQUENCY,NODEID,NETWORKID); #ifdef IS_RFM69HW radio.setHighPower(); //uncomment only for RFM69HW! #endif radio.encrypt(ENCRYPTKEY); //Auto Transmission Control - dials down transmit power to save battery (-100 is the noise floor, -90 is still pretty good) //For indoor nodes that are pretty static and at pretty stable temperatures (like a MotionMote) -90dBm is quite safe //For more variable nodes that can expect to move or experience larger temp drifts a lower margin like -70 to -80 would probably be better //Always test your ATC mote in the edge cases in your own environment to ensure ATC will perform as you expect #ifdef ENABLE_ATC radio.enableAutoPower(ATC_RSSI); #endif sprintf(buffer, "WeatherMote - transmitting at: %d Mhz...", FREQUENCY==RF69_433MHZ ? 433 : FREQUENCY==RF69_868MHZ ? 868 : 915); DEBUGln(buffer); //initialize DS18B20 sensor readstage = 0; resolution = 9; radio.sendWithRetry(GATEWAYID, "START", 6); if (flash.initialize()) flash.sleep(); for (uint8_t i=0; i<=A5; i++) { if (i == RF69_SPI_CS) continue; if (i == FLASH_SS) continue; pinMode(i, OUTPUT); digitalWrite(i, LOW); } SERIALFLUSH(); } char input=0; double C; byte sendLoops=0; byte sendLen; void loop() { if (sendLoops--<=0) //send readings every SEND_LOOPS { sendLoops = SEND_LOOPS-1; //read DS18B20 sensor if (readstage == 0){ getfirstdsadd(myds,dsaddr); dssetresolution(myds,dsaddr,resolution); starttime = millis(); dsconvertcommand(myds,dsaddr); readstage++; } else { if (myds.read()) { C = dsreadtemp(myds,dsaddr, resolution); Serial.println(dsreadtemp(myds,dsaddr, resolution)); readstage=0; } } double celsius1 = dsreadtemp(myds,dsaddr, resolution); dtostrf(celsius1, 3,2, Cstr); //Serial.println(celsius1); sprintf(buffer, "C:%s", Cstr); Serial.println(buffer); sendLen = strlen(buffer); radio.sendWithRetry(GATEWAYID, buffer, sendLen, 1); //retry one time //DEBUG(buffer); DEBUG(" (packet length:"); DEBUG(sendLen); DEBUGln(")"); } //When this sketch is on a node where you can afford the power to keep the radio awake all the time // you can make it receive messages and also make it wirelessly programmable // otherwise this section can be removed if (radio.receiveDone()) { boolean reportStatusRequest=false; DEBUG('[');DEBUG(radio.SENDERID);DEBUG("] "); for (byte i = 0; i < radio.DATALEN; i++) DEBUG((char)radio.DATA[i]); flash.wakeup(); // wireless programming token check - this only works when radio is kept awake to listen for WP tokens CheckForWirelessHEX(radio, flash, true); //first send any ACK to request DEBUG(" [RX_RSSI:");DEBUG(radio.RSSI);DEBUG("]"); if (radio.ACKRequested()) { radio.sendACK(); DEBUG(" - ACK sent."); } DEBUGln(); } SERIALFLUSH(); flash.sleep(); radio.sleep(); //you can comment out this line if you want this node to listen for wireless programming requests LowPower.powerDown(sleepTime, ADC_OFF, BOD_OFF); //DEBUGln("WAKEUP"); } void getfirstdsadd(OneWire myds, byte firstadd[]){ byte i; byte present = 0; byte addr[8]; float celsius; int length = 8; //Serial.print("Looking for 1-Wire devices...\n\r"); while(myds.search(addr)) { //Serial.print("\n\rFound \'1-Wire\' device with address:\n\r"); for( i = 0; i < 8; i++) { firstadd[i]=addr[i]; //Serial.print("0x"); if (addr[i] < 16) { // Serial.print('0'); } // Serial.print(addr[i], HEX); if (i < 7) { //Serial.print(", "); } } if ( OneWire::crc8( addr, 7) != addr[7]) { Serial.print("CRC is not valid!\n"); return; } // the first ROM byte indicates which chip //Serial.print("\n\raddress:"); //Serial.print(addr[0]); return; } } void dssetresolution(OneWire myds, byte addr[8], byte resolution) { // Get byte for desired resolution byte resbyte = 0x1F; if (resolution == 12){ resbyte = 0x7F; } else if (resolution == 11) { resbyte = 0x5F; } else if (resolution == 10) { resbyte = 0x3F; } // Set configuration myds.reset(); myds.select(addr); myds.write(0x4E); // Write scratchpad myds.write(0); // TL myds.write(0); // TH myds.write(resbyte); // Configuration Register myds.write(0x48); // Copy Scratchpad } void dsconvertcommand(OneWire myds, byte addr[8]){ myds.reset(); myds.select(addr); myds.write(0x44,1); // start conversion, with parasite power on at the end } float dsreadtemp(OneWire myds, byte addr[8], byte resolution) { byte present = 0; int i; byte data[12]; byte type_s; float celsius; float fahrenheit; switch (addr[0]) { case 0x10: //Serial.println(F(" Chip = DS18S20")); // or old DS1820 type_s = 1; break; case 0x28: //Serial.println(F(" Chip = DS18B20")); type_s = 0; break; case 0x22: //Serial.println(F(" Chip = DS1822")); type_s = 0; break; default: Serial.println(F("Device is not a DS18x20 family device.")); } present = myds.reset(); myds.select(addr); myds.write(0xBE); // Read Scratchpad //Serial.print(" Data = "); //Serial.print(present,HEX); // Serial.println("Raw Scratchpad Data: "); for ( i = 0; i < 9; i++) { // we need 9 bytes data[i] = myds.read(); // Serial.print(data[i], HEX); // Serial.print(" "); } //Serial.print(" CRC="); //Serial.print(OneWire::crc8(data, 8), HEX); // Serial.println(); // convert the data to actual temperature unsigned int raw = (data[1] << 8) | data[0]; if (type_s) { raw = raw << 3; // 9 bit resolution default if (data[7] == 0x10) { // count remain gives full 12 bit resolution raw = (raw & 0xFFF0) + 12 - data[6]; } else { byte cfg = (data[4] & 0x60); if (cfg == 0x00) raw = raw << 3; // 9 bit resolution, 93.75 ms else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms // default is 12 bit resolution, 750 ms conversion time } } celsius = (float)raw / 16.0; fahrenheit = celsius * 1.8 + 32.0; //Serial.print("Temp (C): "); //Serial.println(celsius); return celsius; }