/****************** code made by PARTH SANTOSH KUNNIR************/ /****************** code is subjected to copy right**************/ // ------------------------------ // Radio // ------------------------------ #include const byte ALIM_TRANSMITTER_PIN = 8; const byte TRANSMITTER_PIN = 9; const byte LED_PIN = 13; #define DEBUG TRUE #define SEND_MESSAGE_DELAY 22500 // Ne pas dépasser 32000 !! Delay in ms between each value's extraction #define SEND_433_PAUSE 160 // 16 multiple // On crée une instance de la classe oneWire pour communiquer avec le materiel on wire (dont le capteur ds18b20) OneWire oneWire(TRANSMITTER_PIN); // Buffer for Oregon message #ifdef THN132N byte OregonMessageBuffer[8]; #else byte OregonMessageBuffer[9]; #endif const unsigned long TIME = 512; const unsigned long TWOTIME = TIME*2; #define SEND_HIGH() digitalWrite(TRANSMITTER_PIN, HIGH) #define SEND_LOW() digitalWrite(TRANSMITTER_PIN, LOW) int moistPin = A6; int moistVal = 0; #include #define SEND_MESSAGE_DELAY 30000 // Ne pas dépasser 32000 !! Delay in ms between each value's extraction #define SEND_433_PAUSE 160 // 16 multiple void setup() { Serial.begin(9600); // Screen Serial.println("Screen init..."); delay(200); pinMode(TRANSMITTER_PIN, OUTPUT); pinMode(ALIM_TRANSMITTER_PIN, OUTPUT); SEND_LOW(); Narcoleptic.delay(1000); } void loop() { delay(200); digitalWrite(ALIM_TRANSMITTER_PIN, HIGH); delay(200); moistVal = analogRead(moistPin); int percent = 2.718282 * 2.718282 * (.008985 * moistVal + 0.207762); //calculate percent for probes about 1 - 1.5 inches apart Serial.println(percent); //Serial.println("% Moisture "); delay(200); sendMessage(0xC0, percent); delay(100); // digitalWrite(ALIM_TRANSMITTER_PIN, LOW); Serial.println("got to sleep"); delay(100); Narcoleptic.delay(SEND_433_PAUSE); // Wait for 30 seconds before send a new message SEND_LOW(); // delay(3000); for (int i=0; i<2; i++) { Narcoleptic.delay(SEND_MESSAGE_DELAY); Narcoleptic.delay(SEND_MESSAGE_DELAY); } } /** * \brief Send logical "0" over RF * \details azero bit be represented by an off-to-on transition * \ of the RF signal at the middle of a clock period. * \ Remenber, the Oregon v2.1 protocol add an inverted bit first */ inline void sendZero(void) { SEND_HIGH(); delayMicroseconds(TIME); SEND_LOW(); delayMicroseconds(TWOTIME); SEND_HIGH(); delayMicroseconds(TIME); } /** * \brief Send logical "1" over RF * \details a one bit be represented by an on-to-off transition * \ of the RF signal at the middle of a clock period. * \ Remenber, the Oregon v2.1 protocol add an inverted bit first */ inline void sendOne(void) { SEND_LOW(); delayMicroseconds(TIME); SEND_HIGH(); delayMicroseconds(TWOTIME); SEND_LOW(); delayMicroseconds(TIME); } /** * Send a bits quarter (4 bits = MSB from 8 bits value) over RF * * @param data Source data to process and sent */ /** * \brief Send a bits quarter (4 bits = MSB from 8 bits value) over RF * \param data Data to send */ inline void sendQuarterMSB(const byte data) { (bitRead(data, 4)) ? sendOne() : sendZero(); (bitRead(data, 5)) ? sendOne() : sendZero(); (bitRead(data, 6)) ? sendOne() : sendZero(); (bitRead(data, 7)) ? sendOne() : sendZero(); } /** * \brief Send a bits quarter (4 bits = LSB from 8 bits value) over RF * \param data Data to send */ inline void sendQuarterLSB(const byte data) { (bitRead(data, 0)) ? sendOne() : sendZero(); (bitRead(data, 1)) ? sendOne() : sendZero(); (bitRead(data, 2)) ? sendOne() : sendZero(); (bitRead(data, 3)) ? sendOne() : sendZero(); } /******************************************************************/ /******************************************************************/ /******************************************************************/ /** * \brief Send a buffer over RF * \param data Data to send * \param size size of data to send */ void sendData(byte *data, byte size) { for(byte i = 0; i < size; ++i) { sendQuarterLSB(data[i]); sendQuarterMSB(data[i]); } } /** * \brief Send an Oregon message * \param data The Oregon message */ void sendOregon(byte *data, byte size) { sendPreamble(); //sendSync(); sendData(data, size); sendPostamble(); } /** * \brief Send preamble * \details The preamble consists of 16 "1" bits */ inline void sendPreamble(void) { byte PREAMBLE[]={0xFF,0xFF}; sendData(PREAMBLE, 2); } /** * \brief Send postamble * \details The postamble consists of 8 "0" bits */ inline void sendPostamble(void) { #ifdef THN132N sendQuarterLSB(0x00); #else byte POSTAMBLE[]={0x00}; sendData(POSTAMBLE, 1); #endif } /** * \brief Send sync nibble * \details The sync is 0xA. It is not use in this version since the sync nibble * \ is include in the Oregon message to send. */ inline void sendSync(void) { sendQuarterLSB(0xA); } /******************************************************************/ /******************************************************************/ /******************************************************************/ /** * \brief Set the sensor type * \param data Oregon message * \param type Sensor type */ inline void setType(byte *data, byte* type) { data[0] = type[0]; data[1] = type[1]; } /** * \brief Set the sensor channel * \param data Oregon message * \param channel Sensor channel (0x10, 0x20, 0x30) */ inline void setChannel(byte *data, byte channel) { data[2] = channel; } /** * \brief Set the sensor ID * \param data Oregon message * \param ID Sensor unique ID */ inline void setId(byte *data, byte ID) { data[3] = ID; } /** * \brief Set the sensor battery level * \param data Oregon message * \param level Battery level (0 = low, 1 = high) */ void setBatteryLevel(byte *data, byte level) { if(!level) data[4] = 0x0C; else data[4] = 0x00; } /** * \brief Set the sensor temperature * \param data Oregon message * \param temp the temperature */ void setTemperature(byte *data, float temp) { // Set temperature sign if(temp < 0) { data[6] = 0x08; temp *= -1; } else { data[6] = 0x00; } // Determine decimal and float part int tempInt = (int)temp; int td = (int)(tempInt / 10); int tf = (int)round((float)((float)tempInt/10 - (float)td) * 10); int tempFloat = (int)round((float)(temp - (float)tempInt) * 10); // Set temperature decimal part data[5] = (td << 4); data[5] |= tf; // Set temperature float part data[4] |= (tempFloat << 4); } /** * \brief Set the sensor humidity * \param data Oregon message * \param hum the humidity */ void setHumidity(byte* data, byte hum) { data[7] = (hum/10); data[6] |= (hum - data[7]*10) << 4; //Serial.print("Hum=" + hum); } /** * \brief Sum data for checksum * \param count number of bit to sum * \param data Oregon message */ int Sum(byte count, const byte* data) { int s = 0; for(byte i = 0; i> 4; s += (data[i]&0xF); } if(int(count) != count) s += (data[count]&0xF0) >> 4; return s; } /** * \brief Calculate checksum * \param data Oregon message */ void calculateAndSetChecksum(byte* data) { #ifdef THN132N int s = ((Sum(6, data) + (data[6]&0xF) - 0xa) & 0xff); data[6] |= (s&0x0F) << 4; data[7] = (s&0xF0) >> 4; #else data[8] = ((Sum(8, data) - 0xa) & 0xFF); #endif } /******************************************************************/ /******************************************************************/ /******************************************************************/ void sendMessage(byte ID, double Irms) { // LA LECTURE DE LA TENSION FAIT PLANTER LES PORTS ANALOGIQUES ???? long currentVcc = 5000; //readVcc(); // Create the Oregon message for a temperature/humidity sensor (THGR2228N) byte TYPE[] = {0x1A,0x2D}; setType(OregonMessageBuffer, TYPE); setChannel(OregonMessageBuffer, 0x20); setId(OregonMessageBuffer, ID); if (currentVcc > 5000) { currentVcc = 5000; } if (currentVcc < 3800) { setBatteryLevel(OregonMessageBuffer, 0); // 0 : low, 1 : high } else { setBatteryLevel(OregonMessageBuffer, 1); // 0 : low, 1 : high } setTemperature(OregonMessageBuffer, 0); setHumidity(OregonMessageBuffer, abs(int(Irms))); // Calculate the checksum calculateAndSetChecksum(OregonMessageBuffer); // Show the Oregon Message // for (byte i = 0; i < sizeof(OregonMessageBuffer); ++i) { // Serial.print(OregonMessageBuffer[i] >> 4, HEX); // Serial.print(OregonMessageBuffer[i] & 0x0F, HEX); // // } // Serial.println(""); // Send the Message over RF sendOregon(OregonMessageBuffer, sizeof(OregonMessageBuffer)); // Send a "pause" SEND_LOW(); delayMicroseconds(TWOTIME*8); // Send a copie of the first message. The v2.1 protocol send the // message two time sendOregon(OregonMessageBuffer, sizeof(OregonMessageBuffer)); SEND_LOW(); }