/* ========================================================================================= * * CS408 Environmental Monitoring Independent of Existing Infrastructure * Copyright (C) 2021 Callum Inglis * * 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 2 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. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Contact: Callum.Inglis.2018(at)uni.strath.ac.uk * * ========================================================================================= * * Libraries Used * ArduinoJson v6 Library - https://arduinojson.org/v6/doc/ (https://github.com/sandeepmistry/arduino-LoRa/blob/master/LICENSE) * LoRa Library - https://github.com/sandeepmistry/arduino-LoRa/blob/master/API.md (https://github.com/bblanchon/ArduinoJson/blob/6.x/LICENSE.md) * SHTSensor - https://github.com/Sensirion/arduino-sht (https://github.com/Sensirion/arduino-sht/blob/master/LICENSE) * * ========================================================================================= */ #include <TimeLib.h> #include <SPI.h> #include <Wire.h> #include <LoRa.h> #include <SoftwareSerial.h> #include <ArduinoJson.h> #include <base64.h> #include "SHTSensor.h" // Debug / Polling / Transmitting Config #define DEBUG 1 #define MIN_RAND_DELAY 500 // ms #define MAX_RAND_DELAY 1250 // ms #define POLLING_FREQUENCY 2500 // ms Take value every POLLING_FREQUENCY ms #define MAX_TRANSMISSION_RETRIES 5 // No. Retries before recordings new values then retry #define TX_AFTER_N_READINGS 10 // No. of samples, after which Transmit Avg Readings #define TX_RESERVATION_TIME 1 // How long do we require use of TX for sending packets? (Seconds) int pollEventCount = 0; // Number of times data has been sampled in this recording period // Lora Config #define ss 16 // Physical Pin 16 = D0 (Default is Physical Pin 5) #define rst 0 #define dio0 15 // Physical Pin 15 = D8 (Default is Physical Pin 4) static const int loraSpreadingFactor = 7; static const int loraSignalBandwidth = 125E3; static const int loraFrequency = 433E6; // Serial PMS Config static const int RXPin = 4, TXPin = 3; // Temp / Humidity Sensor SHTSensor sht; // Particle Sensor Serial SoftwareSerial pmsSerial(2, 3); // LoRa Message Tracking String sensorID = ""; byte localAddress = 0xBB; byte destination = 0xFF; uint32_t msgCount = 0; double temperature; // Sensor Values - Temp double humidity; // Sensor Values - Humidity double co2; // Sensor Values - Co2 uint32_t ppm10; // Sensor Values - Particulate uint32_t ppm25; // Sensor Values - Particulate uint32_t ppm100; // Sensor Values - Particulate // Partial Sensor Data struct pms5003data { uint16_t framelen; uint16_t pm10_standard, pm25_standard, pm100_standard; uint16_t pm10_env, pm25_env, pm100_env; uint16_t particles_03um, particles_05um, particles_10um, particles_25um, particles_50um, particles_100um; uint16_t unused; uint16_t checksum; }; struct pms5003data data; /** * Setup Humidity / Temperature Sensor */ bool setupSHT() { Wire.begin(); if (!sht.init()) { Serial.println("[-] SHT Init Failed"); return false; } sht.setAccuracy(SHTSensor::SHT_ACCURACY_MEDIUM); return true; } double getTemperature() { double t = -1; if (sht.readSample()) { t = sht.getTemperature(); } return t; // -1 on error } double getHumidity() { double h = -1; if (sht.readSample()) { h = sht.getHumidity(); } return h; // -1 on error } /** * TODO getCo2() */ double getCo2() { return 0; } // TODO DOC void resetCounters() { ppm10 = 0; ppm25 = 0; ppm100 = 0; temperature = 0; humidity = 0; pollEventCount = 0; } bool setupLoRa() { LoRa.setPins(ss, rst, dio0); if (!LoRa.begin(loraFrequency)) { Serial.println("[-] Fatal. Starting LoRa failed!"); return false; } LoRa.setSpreadingFactor(loraSpreadingFactor); LoRa.setSignalBandwidth(loraSignalBandwidth); Serial.println("[+] LoRa Initialized OK!"); return true; } /* * Return ESP Module ID, based on MAC address * Source: https://arduino.stackexchange.com/a/58678 * * 2021-11-07 - This method proved unreliable, switched to casting ESP.getChipID() as a string instead */ String getSensorUID() { String sensorID = "EMIEI-"; // [E]nviornmental [M]onitoring [I]ndepenet of [E]xisting [I]nfrastructure sensorID.concat(String(ESP.getChipId())); return sensorID; } /** * Get data from PMS Partical Sensor * @param Stream s PMS Serial Connection * @modifies struct data PMS Sensor Data * @returns boolean Data Read Success status */ boolean readPMSdata(Stream *s) { if (!s->available()) { return false; } // Read a byte at a time until we get to the special '0x42' start-byte if (s->peek() != 0x42) { s->read(); return false; } // Now read all 32 bytes if (s->available() < 32) { return false; } uint8_t buffer[32]; uint32_t sum = 0; s->readBytes(buffer, 32); // get checksum ready for (uint8_t i=0; i<30; i++) { sum += buffer[i]; } // The data comes in endian'd, this solves it so it works on all platforms uint16_t buffer_u16[15]; for (uint8_t i=0; i<15; i++) { buffer_u16[i] = buffer[2 + i*2 + 1]; buffer_u16[i] += (buffer[2 + i*2] << 8); } // Struct it memcpy((void *)&data, (void *)buffer_u16, 30); if (sum != data.checksum) { Serial.print("\n Checksum failure... "); Serial.print("Expected: "); Serial.print(sum); Serial.print(", Got: "); Serial.print(data.checksum); return false; } return true; } /** * Provided sensor data, construct JSON object ready for transmission, Averaged over numSamples * * @param messageID * @param numSamples Numer of samples averages * @param avgPpm10 Average Particuate readings * @param avgPpm25 Average Particuate readings * @param avgPpm100 Average Particuate readings * @param avgTemperature Average Temperature * @param avgHumidity Average Humidity * @param avgCo2 Average Co2 * * @return DynamicJsonDocument sensorData */ DynamicJsonDocument prepareSensorData(int messageID, int numSamples, uint32_t avgPpm10, uint32_t avgPpm25, uint32_t avgPpm100, double avgTemperature, double avgHumidity, double avgCo2) { DynamicJsonDocument doc(2048); JsonObject metadata = doc.createNestedObject("sensorMetadata"); metadata["uid"] = getSensorUID(); metadata["messageID"] = messageID; metadata["samplePeriod"] = numSamples; JsonObject data = doc.createNestedObject("data"); JsonObject ppm = data.createNestedObject("ppm"); // Particulates ppm["p10"] = avgPpm10; ppm["p25"] = avgPpm25; ppm["p100"] = avgPpm100; JsonObject sht = data.createNestedObject("sht"); // Temp, Humidity sht["temperature"] = avgTemperature; sht["humidity"] = avgHumidity; JsonObject co2 = data.createNestedObject("co2"); // TODO Co2 co2["tmp"] = avgCo2; return doc; } /** * Listen on Lora for other messages, returns true if no messages detected within [listenDuration] seconds * Use prior to transmissions to avoid interruption of other messages * * @param int listenDuration How long to listen on Lora RX in Seconds * @returns boolean If messages detected within listenDuration */ boolean clearToSend(int listenDuration) { int listenUntil = now() + listenDuration; // Listen until timeout expires while (listenUntil >= now()) { int packetSize = LoRa.parsePacket(); if (packetSize) { Serial.println("[-] TX Busy - Not Clear To Send"); return false; // Other message heard on Rx, infer that we can not transmit just now. } delay(5); } return true; // We didn't hear anything, so continue } // Introduce random delay to avoid another collision void waitRandomDelay(int minSeconds = 0) { int randDelay = (minSeconds * 1000) + random(MIN_RAND_DELAY, MAX_RAND_DELAY); if (DEBUG){ Serial.println("[i] Delay for " + String(randDelay) + "ms"); } delay(randDelay); } /** * Send short "clear to send?" packet * Tx - "I've got data to send!" + UID * @param messageID ID of this message / sample period */ void sendTxHello(int messageID) { Serial.println("[+] Transmit - \"Hello\""); DynamicJsonDocument txHello(2048); txHello["uid"] = getSensorUID(); txHello["reservationTime"] = TX_RESERVATION_TIME; txHello["messageID"] = messageID; sendJsonPayloadWithLoRa(txHello); } /** * Send Payload * Tx - Sensor Payload * @param payload JSON Payload to be sent */ void sendTxPayload(DynamicJsonDocument payload) { Serial.println("[+] Transmit - Payload"); sendJsonPayloadWithLoRa(payload); } /** * Listen for messages on TX, expecting JSON * * @param listenDuration How long to listen on Lora RX in Seconds * @return StaticJsonDocument|null RX Payload in JSON, null on timeout reached or error */ StaticJsonDocument<1024> listenForAndConsumeMessage(int listenDuration) { int listenUntil = now() + listenDuration; StaticJsonDocument<1024> json; // Listen until timeout expires while (listenUntil >= now()) { int packetSize = LoRa.parsePacket(); if (!packetSize) { delay(3); continue; } // Read in packet, ensure we only bring in anything after { and before } inclusive String incoming = ""; char temp; while (LoRa.available()) { temp = (char)LoRa.read(); if (incoming.length() == 0 && temp == '{') { // Opening { incoming = "{"; } else if (temp == '}') { // Closing } incoming.concat("}"); break; } else if (incoming.length() > 0) { // Anything else that's valid incoming.concat(temp); } } // Deserialize - TODO Error Handling https://arduinojson.org/v6/api/json/deserializejson/ deserializeJson(json, incoming); break; } return json; } /** * Listen for response to TxHello for [listenDuration] seconds, check Sensor UID & Message ID match and return true if we have clear to transmit payload. * @param listenDuration How long to listen on Lora RX in Seconds * @param messageID ID of message we are expecting to receive * @return boolean Clear to Transmit */ boolean listenForTxHelloAccept(int listenDuration, int messageID) { Serial.println("[+] Transmit - \"Hello\" - Listening for \"Hello\" Ack & Clear to Send"); StaticJsonDocument<1024> json = listenForAndConsumeMessage(listenDuration); // Timeout, likely TX Hello was not recieved or ack got lost if (json.isNull()) { Serial.println("[-] Transmit - \"Hello\" - Timeout while waiting for Clear to Send\n\n"); return false; } const bool okToTransmit = json["okTransmit"]; const String authIsForUid = json["uid"]; const int authIsForMessageID = json["messageID"]; const String gatewayUid = json["gatewayUid"]; // Verify txHello.okTransmit is True and Sensor UID & Message IDs Match if (DEBUG) { if (authIsForUid == getSensorUID()) { Serial.println("[+] Transmit - \"Hello\" - Sensor UID Match!"); } else { Serial.println("[-] Transmit - \"Hello\" - Sensor UID Mis-Match! " + String(authIsForUid) + " vs " + String(getSensorUID())); } if (authIsForMessageID == messageID) { Serial.println("[+] Transmit - \"Hello\" - Message ID Match!"); } else { Serial.println("[-] Transmit - \"Hello\" - MessageID Mis-Match!"); } } // Ok To Trasmit, Sensor UID Match & Message ID Match bool clearToSend = (okToTransmit && authIsForUid == getSensorUID() && authIsForMessageID == messageID); if (DEBUG) { if (clearToSend) { Serial.println("[+] Transmit - \"Hello\" - Recieved \"Clear to Transmit\" Payload"); } else { Serial.println("[-] Transmit - \"Hello\" - Can Not Transmit At This Time"); } } return clearToSend; } // TODO DOC boolean listenForTxPayloadAccept(int listenDuration, int messageID) { Serial.println("[.] Transmit - Payload - Listening for Ack"); StaticJsonDocument<1024> json = listenForAndConsumeMessage(listenDuration); // Timeout, likely TX Payload was not recieved or ack got lost. if (json.isNull()) { Serial.println("[-] Transmit - Payload - Ack Timeout Reached - Assuming Message Was Not Delivered\n\n"); return false; } const bool ackStatus = json["ackStatus"]; const String authIsForUid = json["uid"]; const int authIsForMessageID = json["replyMsgID"]; const String gatewayUid = json["gatewayUid"]; // Verify Sensor UID Match if (authIsForUid == getSensorUID() && authIsForMessageID == messageID) { Serial.println("[+] Transmit - Payload - Ack Recieved: " + String(ackStatus) + "\n"); if (ackStatus) { return true; } // It all worked :) // TODO Retransmit, recover, etc Serial.println("[-] Transmit - Payload - Ack Failed - TODO Setup Retransmission"); return false; } // TODO Else UID Mis-Match so we wait for next message Serial.println("[-] Transmit - Payload - Ack Message ID or Sensor ID Mis-Match"); return false; } /** * Send JSON Payload over LoRa * @param payload JSON Payload to be send */ void sendJsonPayloadWithLoRa(DynamicJsonDocument payload) { LoRa.beginPacket(); serializeJson(payload, LoRa); LoRa.endPacket(); } // TODO - Finish Acks & Naks boolean transmitData(DynamicJsonDocument payload) { // TODO MAX_RETRIES // Listen for other communication // Rx - Listen for other messages, if no messages heard then continue if (!clearToSend(0.5)) { waitRandomDelay(); // Wait for short time before retrying while (!clearToSend(0.5)) { waitRandomDelay(); } // TODO MAX_TIMEOUT } // Send TX Hello sendTxHello(msgCount); // Await TX Hello Auth - Expect: Timeout | Not Auth | Accept + Clear To Transmit if (!listenForTxHelloAccept(TX_RESERVATION_TIME * 1.5, msgCount)) { return false; // Can't transmit just now, we will retry } // Send TX Payload sendTxPayload(payload); // Await TX Payload Ack - Expect: Timeout | Nack | Accept + Data Match if (!listenForTxPayloadAccept(2, msgCount)) { return false; // TODO Ack Failed Setup a retry here! } // TODO Update Sensor Config // TODO Clear values & Continue resetCounters(); Serial.println("Packet Sent Succesfully\n"); Serial.println("---------------+++++-------------------"); msgCount++; return true; } void setup() { delay(1000); Serial.begin(115200); // Console Debug Serial.println("\n\n[+] Transmitter Node"); pmsSerial.begin(9600); // Partical Sensor // Setup Hardware if (!setupSHT()) { while(1); } // Temp/Humidity - Die on Error if (!setupLoRa()) { while(1); } // Die on error } // Main void loop() { // TODO Gather Sensor Data // Error reading PMS Data, ignore on this round if (!readPMSdata(&pmsSerial)) { data.pm10_standard = 0; data.pm25_standard = 0; data.pm100_standard = 0; } pollEventCount++; if (DEBUG) { Serial.println(); Serial.print(String(pollEventCount) + ") "); Serial.print("PM 1.0: "); Serial.print(data.pm10_standard); Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_standard); Serial.print("\t\tPM 10: "); Serial.print(data.pm100_standard); Serial.print("\t\tTemp: "); Serial.print(getTemperature()); Serial.print("\t\tHumidity: "); Serial.print(getHumidity()); Serial.print("\t\tCo2: "); Serial.print(getCo2()); } // Add to Average temperature += getTemperature(); humidity += getHumidity(); co2 += getCo2(); ppm10 = ppm10 + data.pm10_standard; // Standard (_standard) or Environmental (_env) readings for Particulate Data ppm25 = ppm25 + data.pm25_standard; ppm100 = ppm100 + data.pm100_standard; // If we should now transmit if (pollEventCount >= TX_AFTER_N_READINGS) { // Average Values over recording period double avgTemperature = temperature / pollEventCount; double avgHumidity = humidity / pollEventCount; double avgCo2 = co2 / pollEventCount; uint32_t avgPpm10 = ppm10 / pollEventCount; uint32_t avgPpm25 = ppm25 / pollEventCount; uint32_t avgPpm100 = ppm100 / pollEventCount; if (DEBUG) { Serial.println(""); Serial.print("Avg ppm10: "); Serial.print(avgPpm10); Serial.print("\t\tAvg ppm25: "); Serial.print(avgPpm25); Serial.print("\t\tAvg ppm100: "); Serial.print(avgPpm100); Serial.print("\t\tAvg Temp: "); Serial.print(avgTemperature); Serial.print("\t\tAvg Humidity: "); Serial.print(avgHumidity); Serial.print("\t\tAvg Co2: "); Serial.print(avgCo2); Serial.print("\t\tChip ID: "); Serial.println(getSensorUID()); Serial.println(""); } // Prepare Data For Send DynamicJsonDocument sensorData = prepareSensorData(msgCount, pollEventCount, avgPpm10, avgPpm25, avgPpm100, avgTemperature, avgHumidity, avgCo2); // Transmit if (transmitData(sensorData)) { return; // It all worked, values reset, now record new values } // Transmission failed, handle re-tries int numRetries = 1; while (!transmitData(sensorData) && numRetries < MAX_TRANSMISSION_RETRIES){ numRetries++; Serial.println("[-] Failed to send packet, retrying. Attempt " + String(numRetries) + " of " + String(MAX_TRANSMISSION_RETRIES) + "\n"); waitRandomDelay(TX_RESERVATION_TIME); // Introduce random delay to avoid another collision } // We were able to transmit after retries, values reset, now record new values if (numRetries < MAX_TRANSMISSION_RETRIES) { return; } // Failed to transmit - Don't Clear Counters, record more values then try to retransmit on next send Serial.println("[-] Failed to send packet, max retries reached. Aborting"); return; } delay(POLLING_FREQUENCY); }