Augustin De Piante, Justin Peetz, Luke Sewing

Published April 20, 2021

IOT Based Air Monitoring Mesh System

A simple array of a few Particle Argons to monitor and report environmental conditions of a mesh network of several spaces.

IntermediateFull instructions provided920

Things used in this project

Hardware components

Particle Argon

Seeed Studio Grove - Barometer Sensor (BMP280)

Seeed Studio Grove - Dust Sensor（PPD42NS）

Seeed Studio Grove - OLED Display 1.12'' V2

Adafruit Accessories Grove Shield FeatherWing for Particle Mesh and all Feathers

Seeed Studio Seeed Grove - Universal 4 Pin 20cm Unbuckled Cable (5 PCs Pack)

Software apps and online services

Particle Build Web IDE

Discord

Fritzing Circuit Design

Solidworks

Hand tools and fabrication machines

3D Printer (generic)

Story

MEGR 3171 Instrumentation IOT Project (Team #1).

The basis for this project was to utilize a collection of Particle Argons to gather, publish, and chart data pertaining to environmental conditions. The purpose of this data is to aid in the monitoring of a room or space remotely over the internet, as opposed to requiring a physical connection. This allows for separate spaces to be observed from anywhere with internet access. The way this works is through the utilization of the Particle.publish and Particle.subscribe functions provided by the Particle API. These functions send and receive messages from other devices in your network. Our project utilizes two independent air monitor modules that communicate with a central data handling hub. This third Argon transmits data to ThingSpeak and Discord, and also communicates back to the air monitors to ensure their proper function as well as meet project requirements. Additionally, the monitors communicate with each other by sending conditional acknowledgements back and forth, with accompanying LED visual confirmations using the onboard RGB LED. These LEDs work much like a Useless Machine, with each one repetitively triggering an event that assigns an updated value to a variable, which subsequently triggers the other argon back to the original value, repeating the process indefinitely.

A case was designed to house the components for the project. The main part of the case was 3D printed and the lid was CNC machined from carbon fiber for aesthetics. Files can be found on Thingiverse.

Particle Air Monitor Enclosure - Thingiverse

1 / 5

A flow chart was generated to aid in the overall e

ThingSpeak Integration:

The data is graphed on ThingSpeak for a powerful visual aid in interpreting data. The Channel is publicly available at the following link:

ThingSpeak Data HERE.

An example image of this data can be seen below.

ThingSpeak Live Data

Discord Integration:

In addition to sending data to ThingSpeak, the data is also sent to a Discord channel for simple and convenient updates. Fast, mobile communication is what sets our project apart. Our project is fully integrated with our Discord server that delivers nearly instant and insightful updates. This is done through Webhooks (Explained in more depth in the "Code Specifics" section), yielding the output below.

Discord Information

Code Specifics:

Because the Air Monitor units needed to communicate with each other, as well as output data simultaneously to ThingSpeak, there are two very slight variations of the Air Monitor Code.

The differences fall on:

Line 31:

Change:

const String key = "YOUR_KEY_HERE";  //thingspeak Write Key

To: The key you can find on your personal ThingSpeak Page.

Line 85:

Change:

Particle.subscribe(“ack_from_luke”, ack received);

To:

Particle.subscribe(“ack_from_gus”, ack received);

Line 112:

Change:

int ack_from_gus = 0;

To:

int ack_from_luke = 0;

Line 116:

Change:

int ack_from_gus = 1;

To:

int ack_from_luke = 1;

Line 120:

Change:

Particle.publish("ack_outbound_gus", String(ack_from_gus), PRIVATE);

To:

Particle.publish("ack_outbound_luke", String(ack_from_luke), PRIVATE);

Line 124:

Change:

int ack_from_gus = 0;

To:

int ack_from_luke = 0;

Line 128:

Change:

Particle.publish("ack_outbound_gus", String(ack_from_gus), PRIVATE);

To:

Particle.publish("ack_outbound_luke", String(ack_from_luke), PRIVATE);

Line 245:

Change:

String discord_data = String::format "**__Gus's House…

To:

String discord_data = String::format "**__Luke's House…

The change here is made to correctly display the data as originating from Luke’s Air monitor when reporting to Discord. A webhook handles the publishing of data by simply sending the JSON data below, which is managed by Discord’s native Webhook integrations. The data recorded from the sensors is all contained in the {{{PARTICLE_EVENT_VALUE}}} field.

{

"event": "{{{PARTICLE_EVENT_NAME}}}",

"data": "{{{PARTICLE_EVENT_VALUE}}}",

"coreid": "{{{PARTICLE_DEVICE_ID}}}",

"published_at": "{{{PARTICLE_PUBLISHED_AT}}}",

"content": "{{{PARTICLE_EVENT_VALUE}}}"

}

Line 262-5:

Change:

Particle.publish("thingspeak", +
"{ \"1\": \"" + String(temp) + "\","
"\"2\": \"" + String(humidity) + "\"," +
"\"3\": \"" + String(pressure) + "\"," +
"\"4\": \"" + String(concentration) + "\"," +…

To:

Particle.publish("thingspeak", +
"{ \"5\": \"" + String(temp) + "\","
"\"6\": \"" + String(humidity) + "\"," +
"\"7\": \"" + String(pressure) + "\"," +
"\"8\": \"" + String(concentration) + "\"," +…

The changes made on Lines 262-265 direct the second air monitor to give values to fields 5-8 of the Webhook handling the publication of data to ThingSpeak. The Webhook in the Particle Console sends the data to ThingSpeak by completing the provided template, yielding the code below:

{

"event": "{{{PARTICLE_EVENT_NAME}}}",

"data": "{{{PARTICLE_EVENT_VALUE}}}",

"coreid": "{{{PARTICLE_DEVICE_ID}}}",

"published_at": "{{{PARTICLE_PUBLISHED_AT}}}",

"api_key": "{{k}}",

"field1": "{{1}}",

"field2": "{{2}}",

"field3": "{{3}}",

"field4": "{{4}}",

"field5": "{{5}}",

"field6": "{{6}}",

"field7": "{{7}}",

"field8": "{{8}}"

}

Fields 1-4 are from Gus’s Argon, while Fields 5-8 are from Luke’s house. The changes are done in this way to condense the data into a single ThingSpeak channel while reporting from two separate locations.

Resources:

Original Inspiration from Particle

The code for this project was at first in large measure imitated from the link above. Since then, it has been vastly modified to improve connectivity, meet more demanding requirements, and increase function.

Particle Publish/Subscribe Resources

General Particle Documentation. A living document, it should be your first point of reference for any project you wish to complete.

Particle WebHook Resources

The above link proved an excellent resource for setting up the Webhooks used in this project.

Particle Discussion Board

Incredibly valuable tool for debugging and troubleshooting. Someone has had your issue before, and someone else has answered the question.

Schematics

Code

#include "Particle.h"                   //Begin including libraries. This is the library for the Particle itself.
#include "Air_Quality_Sensor.h"         //Library for Air Quality Sensor.
#include "Adafruit_BME280.h"            //Library for BME280.
#include "SeeedOLED.h"                  //Library for OLED Display.

#define AQS_PIN A2                      //Defines Analog Pin 2 for our Air Quality Sensor.
#define DUST_SENSOR_PIN D4              //Defines Digital Pin 4 for our Dust Sensor.
#define SENSOR_READING_INTERVAL 1000    //Defines the Sensor Read Interval.

SYSTEM_THREAD(ENABLED);

int temp = 0;                           //Placeholder for Temperature value.
int humidity = 0;                       //Placeholder for Humidity value.
int pressure = 0;                       //Placeholder for Pressure value.
int brightnessPotVal = 50;
int red = 255;
int blue = 255;
int green = 255;
int did_this_come_in = FALSE;

unsigned long lastInterval;             
unsigned long lowpulseoccupancy = 0;
unsigned long last_lpo = 0;
unsigned long duration;

float ratio = 0;
float concentration = 0;

char pang[1] = {0};

const String key = "LWVHBUBP1V7UB09D";  //thingspeak Write Key

int getBMEValues(int &temp, int &humidity, int &pressure);                                  //
void getDustSensorReadings();                                                               ////
String getAirQuality();                                                                     //////
AirQualitySensor aqSensor(AQS_PIN);                                                         ////////
Adafruit_BME280 bme;                                                                        ////////// Function Prototypes
void updateDisplay(int temp, int humidity, int pressure, String airQuality);                ////////
void discord(int temp, int humidity, int pressure, float concentration);                    //////
void pong( const char *event, const char *data);                                            ////
void write_all_to_ThingSpeak(int temp, int humidity, int pressure, float concentration);    //

void setup()
{
    Serial.begin(9600);
    delay(50);
    pinMode(DUST_SENSOR_PIN, INPUT);
    pinMode(D7, OUTPUT);
    
    if (aqSensor.init())
        {
        Serial.println("Air Quality Sensor ready.");
        }
    else
        {
        Serial.println("Air Quality Sensor ERROR!");
        }

    Wire.begin();
    SeeedOled.init();

    SeeedOled.clearDisplay();
    SeeedOled.setNormalDisplay();
    SeeedOled.setPageMode();

    SeeedOled.setTextXY(2, 0);
    SeeedOled.putString("----------");
    SeeedOled.setTextXY(3, 0);
    SeeedOled.putString("Trump 2024");
    SeeedOled.setTextXY(4, 0);
    SeeedOled.putString("----------");

  if (bme.begin())
  {
    Serial.println("BME280 Sensor ready.");
  }
  else
  {
    Serial.println("BME280 Sensor ERROR!");
  }

  lastInterval = millis();
  
    Particle.subscribe("Echo", pong);
    Particle.subscribe("ack_outbound_luke", ack_received);

}

void loop()
{
    duration = pulseIn(DUST_SENSOR_PIN, LOW);
    lowpulseoccupancy = lowpulseoccupancy + duration;

    if ((millis() - lastInterval) > SENSOR_READING_INTERVAL)
    {
    String quality = getAirQuality();
    Serial.printlnf("Air Quality: %s", quality.c_str());

    getBMEValues(temp, pressure, humidity);
    Serial.printlnf("Temp: %d", temp);
    Serial.printlnf("Pressure: %d", pressure);
    Serial.printlnf("Humidity: %d", humidity);

    getDustSensorReadings();

    updateDisplay(temp, humidity, pressure, quality);

    lowpulseoccupancy = 0;
    lastInterval = millis();
    }
    
    int ack_from_gus = 0;
    delay(15000);
    if (did_this_come_in = (TRUE))
    {
        ack_from_gus = 1;
        RGB.control(TRUE);
        RGB.color(0, 0, green);
        RGB.brightness(brightnessPotVal);
        Particle.publish("ack_outbound_gus", String(ack_from_gus), PRIVATE);
        delay(15000);
    }
    
    ack_from_gus = 0;
    RGB.control(TRUE);
    RGB.color(red, 0, 0);
    RGB.brightness(brightnessPotVal);
    Particle.publish("ack_outbound_gus", String(ack_from_gus), PRIVATE);

    
    
    if (pang != 0)
    {
        digitalWrite(D7, HIGH);
        delay(1000);
        digitalWrite(D7, LOW);
        delay(1000);
    }
    write_all_to_ThingSpeak(temp, humidity, pressure, concentration);
    discord(temp, humidity, pressure, concentration);
    delay(1800000);



}

String getAirQuality()
{
  int quality = aqSensor.slope();
  String qual = "None";

  if (quality == AirQualitySensor::FORCE_SIGNAL)
  {
    qual = "Danger";
  }
  else if (quality == AirQualitySensor::HIGH_POLLUTION)
  {
    qual = "High Pollution";
  }
  else if (quality == AirQualitySensor::LOW_POLLUTION)
  {
    qual = "Low Pollution";
  }
  else if (quality == AirQualitySensor::FRESH_AIR)
  {
    qual = "Fresh Air";
  }

  return qual;
}

int getBMEValues(int &temp, int &pressure, int &humidity)
{
  temp = (int)bme.readTemperature();
  pressure = (int)(bme.readPressure() / 100.0F);
  humidity = (int)bme.readHumidity();

  return 1;
}

void getDustSensorReadings()
{
  // This particular dust sensor returns 0s often, so let's filter them out by making sure we only
  // capture and use non-zero LPO values for our calculations once we get a good reading.
  if (lowpulseoccupancy == 0)
  {
    lowpulseoccupancy = last_lpo;
  }
  else
  {
    last_lpo = lowpulseoccupancy;
  }

  ratio = lowpulseoccupancy / (SENSOR_READING_INTERVAL * 10.0);                   // Integer percentage 0=>100
  concentration = 1.1 * pow(ratio, 3) - 3.8 * pow(ratio, 2) + 520 * ratio + 0.62; // using spec sheet curve

  Serial.printlnf("LPO: %lu", lowpulseoccupancy);
  Serial.printlnf("Ratio: %f%%", ratio);
  Serial.printlnf("Concentration: %f pcs/L", concentration);
}

void updateDisplay(int temp, int humidity, int pressure, String airQuality)
{
  SeeedOled.clearDisplay();

  SeeedOled.setTextXY(0, 0);
  SeeedOled.putString(airQuality);

  SeeedOled.setTextXY(2, 0);
  SeeedOled.putString("Temp: ");
  SeeedOled.putNumber(temp);
  SeeedOled.putString("C");

  SeeedOled.setTextXY(3, 0);
  SeeedOled.putString("Humidity: ");
  SeeedOled.putNumber(humidity);
  SeeedOled.putString("%");

  SeeedOled.setTextXY(4, 0);
  SeeedOled.putString("Press: ");
  SeeedOled.putNumber(pressure);
  SeeedOled.putString(" hPa");

    if (concentration > 1)
      {
        SeeedOled.setTextXY(5, 0);
        SeeedOled.putString("Dust: ");
        SeeedOled.putNumber(concentration); // Will cast our float to an int to make it more compact
        SeeedOled.putString(" pcs/L");
      }
}

void discord(int temp, int humidity, int pressure, float concentration)
{
    digitalWrite(D7, HIGH);                                                                                             //Turns on onboard LED 
    delay(1000);                                                                                                        //For 1000ms
    digitalWrite(D7, LOW);                                                                                              //Turns off onboard LED 
    delay(1000);                                                                                                        //For 1000ms
    String discord_data = String::format(
        "**__Gus's House__**\n```Temperature: %d°C\nHumidity: %d\%\nPressure: %dhPa\nDust Concentration: %fpcs/L```", 
        temp, humidity, pressure, concentration);
    Particle.publish("net-data", discord_data, PRIVATE);
}

void pong( const char *event, const char *data)
{
            
    for(int i = 0; i < 1; i++)
        {
        pang[i] = data[i];      //Assigns the value of data to pang 
        }
}

void write_all_to_ThingSpeak(int temp, int humidity, int pressure, float concentration) //
{
    Particle.publish("thingspeak", +
     "{ \"1\": \"" + String(temp) + "\"," +                 // Change values 1-4 to 5-8 for second monitor.
        "\"2\": \"" + String(humidity) + "\"," +
        "\"3\": \"" + String(pressure) + "\"," +
        "\"4\": \"" + String(concentration) + "\"," +
        "\"k\": \"" + key + "\" }", PRIVATE);
}

void ack_received(const char *event, const char *data)
{
    if ( (int)data == 1)
    {
    did_this_come_in = TRUE;
    }
}

char discord_data[256] = {0};   //Sets an initial value of 0 to the char that will hold all our data
char ping[1] = {0};             //Sets an initial value of 0 to the char that will hold the temporary value of a conditional variable


void setup() {
    pinMode(D7, OUTPUT);
    Particle.subscribe("net-data", discord_subscribe);  //Subscribe to the particle function that passes data rom the monitors.
    Serial.begin(9600);                                 // Open serial communication for debugging.
}

void loop() {
    
    if (discord_data != 0)                              //Check if the incoming data has a value
    {
        digitalWrite(D7, HIGH);                         //Turn on and off the LED to indicate proper function
        delay(1000);
        digitalWrite(D7, LOW);                          
        delay(1000);
        Particle.publish("Information", discord_data, PRIVATE);         // Publish data to Discord
        delay(60000);
        char ping[1] = {1};                                             // Rewrite the value of ping to true, allowing the two way ccommunication to function.
        Particle.publish("Echo", ping, PRIVATE);                        // Publish data back to Air Monitor
        
    }
}

char discord_subscribe( const char *event, const char *data) {          // Take in data from air monitor and rewrite it to the discord_data buffer.
        for(int i = 0; i < 256; i++){
            discord_data[i] = data[i];
        }
        Serial.print("-------\n");
        Serial.print(data);
        Serial.println("");
        Serial.print(discord_data);
        Serial.println("");
        return 0;
}

IOT Based Air Monitoring Mesh System

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

MEGR 3171 Instrumentation IOT Project (Team #1).

ThingSpeak Integration:

Discord Integration:

Code Specifics:

Resources:

Custom parts and enclosures

Box

Box lid

Schematics

Monitor_Schematic

Monitor Schematic

Code

Air Monitor Code

Message Hub

Credits

Augustin De Piante

Justin Peetz

Luke Sewing

Comments

Embed the widget on your own site

IOT Based Air Monitoring Mesh System

IOT Based Air Monitoring Mesh System

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

MEGR 3171 Instrumentation IOT Project (Team #1).

ThingSpeak Integration:

Discord Integration:

Code Specifics:

Resources:

Custom parts and enclosures

Box

Box lid

Schematics

Monitor_Schematic

Monitor Schematic

Code

Air Monitor Code

Message Hub

Credits

Augustin De Piante

Justin Peetz

Luke Sewing

Comments

Related channels and tags