Skip to content
Snippets Groups Projects

Update sensor config from api; CO2 Sensor; Refactor & Tidy-Up

Merged Update sensor config from api; CO2 Sensor; Refactor & Tidy-Up
update-sensor-config-from-api into DEV
Merged Callum Inglis requested to merge update-sensor-config-from-api into DEV
Viewing commit e133d7c4
Prev Next
Show latest version
1 file
+ 8
− 8
Compare changes
  • Side-by-side
  • Inline
ESP8266_Transmitter/ESP8266_Transmitter.ino
+ 128
− 516
@@ -25,6 +25,7 @@
* 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)
* CCS811 - https://wiki.keyestudio.com/KS0457_keyestudio_CCS811_Carbon_Dioxide_Air_Quality_Sensor
*
* =========================================================================================
*
@@ -38,210 +39,81 @@
#include <LoRa.h>
#include <SoftwareSerial.h>
#include <ArduinoJson.h>
/* #include <base64.h> */
#include "SHTSensor.h"
#include <CCS811.h>
// Debug / Polling / Transmitting Config
#define DEBUG 1
#define MIN_RAND_DELAY 500 // ms
#define MAX_RAND_DELAY 1250 // ms
#define MAX_TRANSMISSION_RETRIES 5 // No. Retries before recordings new values then retry
#define TX_RESERVATION_TIME 1 // How long do we require use of TX for sending packets? (Seconds)
// Variable Values - May be updated by Gateway
int TX_AFTER_N_READINGS = 4; // No. of samples, after which Transmit Avg Readings
int POLLING_FREQUENCY = 30000; // ms Take value every POLLING_FREQUENCY ms
// Definitions, helper files, etc
#include "config.h"
#include "_sht.h"
#include "_co2.h"
#include "_lora.h"
#include "_pms.h"
#include "_transmission.h"
int pollEventCount = 0; // Number of times data has been sampled in this recording period
int pollEventCountPerSensor[NUM_SENSORS] = {0}; // Number of times each sensor has been polled in this recording period (Used for averaging values)
double totalValuePerSensor[NUM_SENSORS] = {0}; // Store reading from each sensor here. We will then average later on
// 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();
}
// Sensor Config
SHTSensor sht; // Temp / Humidity (SHT) Sensor [ic2]
SoftwareSerial pmsSerial(2, 3); // Particle (PMS) Sensor [Serial]
CCS811 co2Sensor; // CO2 Sensor [i2c]
return h; // -1 on error
}
struct pms5003data pmsData; // Struct for PMS Sensor Data
/**
* TODO getCo2()
* Reset Poll Counters & Average Values
* Call after a sampling period to clear collected sensor data
*/
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;
for (int i = 0; i < NUM_SENSORS; i++) {
pollEventCountPerSensor[i] = 0;
totalValuePerSensor[i] = 0;
}
LoRa.setSpreadingFactor(loraSpreadingFactor);
LoRa.setSignalBandwidth(loraSignalBandwidth);
LoRa.setTxPower(20);
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
/**
* Add recorded values to the total for this sample period.
* Do not store false/failed/invalid values, e.g. -1 (-300 for temp sensor)
*
* @param newValue New value recorded for this sensor
* @param idx_sensor_count See config.h - Index of sensor value counts, e.g. IDX_PPM10
*/
String getSensorUID() {
String sensorID = "EMIEI-"; // [E]nviornmental [M]onitoring [I]ndepenet of [E]xisting [I]nfrastructure
sensorID.concat(String(ESP.getChipId()));
return sensorID;
void addValueToTotal(double newValue, int idx_sensor_count) {
if (newValue == -1 || newValue == -300) { // -300 for temp sensor
return;
}
pollEventCountPerSensor[idx_sensor_count] += 1;
totalValuePerSensor[idx_sensor_count] += newValue;
}
/**
* Get data from PMS Partical Sensor
* @param Stream s PMS Serial Connection
* @modifies struct data PMS Sensor Data
* @returns boolean Data Read Success status
* Get average value for a particular sensor, exluding any error values
*
* @param idx_sensor_count See config.h - Index of sensor value counts, e.g. IDX_PPM10
* @return Average value for this sensor, -1 if no values recorded
*/
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;
double getAverageValue(int idx_sensor_count) {
// Ensure we do not divide by 0 (e.g. 0 valid values)
if (pollEventCountPerSensor[idx_sensor_count] == 0) {
return -1;
}
return true;
// Otherwise divide total by number of times we succesfully ampled this value
return totalValuePerSensor[idx_sensor_count] / pollEventCountPerSensor[idx_sensor_count];
}
/**
* 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
*
* @param messageID Number of messages sent since startup
* @param numSamples Numer of samples averages
* @return sensorData in JSON form
*/
DynamicJsonDocument prepareSensorData(int messageID, int numSamples, uint32_t avgPpm10, uint32_t avgPpm25, uint32_t avgPpm100, double avgTemperature, double avgHumidity, double avgCo2) {
DynamicJsonDocument prepareSensorData(int messageID, int numSamples) {
DynamicJsonDocument doc(2048);
JsonObject metadata = doc.createNestedObject("sensorMetadata");
@@ -251,376 +123,116 @@ DynamicJsonDocument prepareSensorData(int messageID, int numSamples, uint32_t av
JsonObject data = doc.createNestedObject("data");
JsonObject ppm = data.createNestedObject("ppm"); // Particulates
ppm["p10"] = avgPpm10;
ppm["p25"] = avgPpm25;
ppm["p100"] = avgPpm100;
JsonObject ppm = data.createNestedObject("ppm"); // Particulates
ppm["p10"] = getAverageValue(IDX_PPM10);
ppm["p25"] = getAverageValue(IDX_PPM25);
ppm["p100"] = getAverageValue(IDX_PPM100);
JsonObject sht = data.createNestedObject("sht"); // Temp, Humidity
sht["temperature"] = avgTemperature;
sht["humidity"] = avgHumidity;
sht["temperature"] = getAverageValue(IDX_TEMPERATURE);
sht["humidity"] = getAverageValue(IDX_HUMIDITY);
JsonObject co2 = data.createNestedObject("co2"); // TODO Co2
co2["tmp"] = avgCo2;
JsonObject co2 = data.createNestedObject("co2"); // CO2
co2["co2"] = getAverageValue(IDX_CO2);
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);
void packageAndSend() {
if (DEBUG) { // Print average values over this period
Serial.println(""); Serial.print("Avg ppm10: "); Serial.print(getAverageValue(IDX_PPM10)); Serial.print("\t\tAvg ppm25: "); Serial.print(getAverageValue(IDX_PPM25)); Serial.print("\t\tAvg ppm100: "); Serial.print(getAverageValue(IDX_PPM100));
Serial.print("\t\tAvg Temp: "); Serial.print(getAverageValue(IDX_TEMPERATURE)); Serial.print("\t\tAvg Humidity: "); Serial.print(getAverageValue(IDX_HUMIDITY)); Serial.print("\t\tAvg Co2: "); Serial.print(getAverageValue(IDX_CO2));
Serial.print("\t\tChip ID: "); Serial.println(getSensorUID()); Serial.println("");
}
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\"");
// Create JSON Object with our values
DynamicJsonDocument sensorData = prepareSensorData(msgCount, pollEventCount);
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);
}
}
Serial.println(incoming);
// 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;
// Transmit
if (transmitData(sensorData)) {
resetCounters();
msgCount++;
return; // It all worked, values reset, now record new values
}
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!");
}
// Transmission failed, handle re-tries
int numRetries = 1;
waitRandomDelay(TX_RESERVATION_TIME*2); // Introduce random delay to avoid another collision / error
// For as long as we are able to retry, attempt transmission again
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*2);
}
// 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");
}
// We were able to transmit after retries, values reset, now record new values
if (numRetries < MAX_TRANSMISSION_RETRIES) {
resetCounters();
msgCount++;
return;
}
return clearToSend;
// 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;
}
// TODO DOC
boolean listenForTxPayloadAccept(int listenDuration, int messageID) {
Serial.println("[.] Transmit - Payload - Listening for Ack");
/********************************************
* Setup Sensor *
********************************************/
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"];
void setup() {
delay(2500); // Allow things to warm up
Serial.begin(115200);
Serial.print("\n\n[+] Hello, I'm a Transmitter Node. My UID is: "); Serial.print(getSensorUID()); Serial.println("");
// Verify Sensor UID Match
if (authIsForUid == getSensorUID()
&& authIsForMessageID == messageID) {
Serial.println("[+] Transmit - Payload - Ack Recieved: " + String(ackStatus) + "\n");
if (ackStatus) { // It all worked :)
// Check for any updated config values
const int newTxAfterNReadings = json["txAfterNReadings"];
if (newTxAfterNReadings != NULL && newTxAfterNReadings != TX_AFTER_N_READINGS) {
TX_AFTER_N_READINGS = newTxAfterNReadings;
Serial.println("[+] Tx After N Readings Updated, now: " + String(TX_AFTER_N_READINGS) + " samples");
}
const int newPollingFrequency = json["pollingFrequency"];
if (newPollingFrequency != NULL && newPollingFrequency != POLLING_FREQUENCY) {
POLLING_FREQUENCY = newPollingFrequency;
Serial.println("[+] Polling Frequency Updated, now: " + String(POLLING_FREQUENCY) + "ms");
}
return true;
}
// 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 * 4, 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;
// Setup / Init Hardware
pmsSerial.begin(9600); // Partical Sensor Start
if (!setupSHT(sht)) { /*while(1);*/ } // Temp/Humidity
if (!setupCO2(co2Sensor)) { /*while(1);*/ } // Co2
if (!setupLoRa()) { while(1); } // LoRa - Critical Component, die on error
}
void setup() {
delay(1000);
Serial.begin(115200); // Console Debug
Serial.println("\n\n[+] Transmitter Node");
pmsSerial.begin(9600); // Partical Sensor
/********************************************
* Main *
********************************************/
// Setup Hardware
if (!setupSHT()) { while(1); } // Temp/Humidity - Die on Error
if (!setupLoRa()) { while(1); } // Die on error
}
void loop() {
delay(POLLING_FREQUENCY);
pollEventCount++;
// Main
void loop() {
// TODO Gather Sensor Data
// Get values from sensors
double instantTemperature = getTemperature(sht); // Prevent polling of sensors too frequently when debugging
double instantHumidity = getHumidity(sht);
double instantCo2 = getCo2(co2Sensor);
// Error reading PMS Data, ignore on this round
if (!readPMSdata(&pmsSerial)) {
data.pm10_standard = 0;
data.pm25_standard = 0;
data.pm100_standard = 0;
int instantPPM10, instantPPM25, instantPPM100;
if (!readPMSdata(&pmsSerial, &pmsData)) { // Error reading PMS Data, ignore on this round
instantPPM10 = instantPPM25 = instantPPM100 = -1;
} else {
instantPPM10 = pmsData.pm10_standard; // Standard (_standard) or Environmental (_env) readings for Particulate Data
instantPPM25 = pmsData.pm25_standard;
instantPPM100 = pmsData.pm100_standard;
}
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());
if (DEBUG) { // Print instantanious values
Serial.println(); Serial.print(String(pollEventCount) + ") "); Serial.print("PM 1.0: "); Serial.print(instantPPM10); Serial.print("\t\tPM 2.5: "); Serial.print(instantPPM25); Serial.print("\t\tPM 10: "); Serial.print(instantPPM100);
Serial.print("\t\tTemp: "); Serial.print(instantTemperature); Serial.print("\t\tHumidity: "); Serial.print(instantHumidity); Serial.print("\t\tCo2: "); Serial.print(instantCo2);
}
// 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;
// Add to running total, we will divide by the number of times samples later on to get an average over sample period
addValueToTotal(instantTemperature, IDX_TEMPERATURE);
addValueToTotal(instantHumidity, IDX_HUMIDITY);
addValueToTotal(instantCo2, IDX_CO2);
addValueToTotal(instantPPM10, IDX_PPM10);
addValueToTotal(instantPPM25, IDX_PPM25);
addValueToTotal(instantPPM100, IDX_PPM100);
// If we should now transmit
// Transmit once we have reached at least N samples
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;
waitRandomDelay(TX_RESERVATION_TIME*2); // Introduce random delay to avoid another collision
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*2); // 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;
packageAndSend();
}
delay(POLLING_FREQUENCY);
}