AirLYTICS

//Author :Hemant Gopalsing
/*****************************************************************INCLUDES******************************************************************/
#include <Time.h>
#include <TimeLib.h>
#include "Arduino.h"
#include "Board.h"
#include "Helium.h"
#include "HeliumUtil.h"
#include <Adafruit_NeoPixel.h>
#include <math.h>
#include <Wire.h>
#include <avr/wdt.h>
#include "BlueDot_BME680.h"
#include <ArduinoJson.h>

/******************************************************************BME680*******************************************************************/
BlueDot_BME680 bme680 = BlueDot_BME680();
void BMEsetup() {
  bme680.parameter.I2CAddress = 0x77;                  // Choose I2C Address
  bme680.parameter.sensorMode = 0b01;                  // Default sensor mode = Single measurement, then sleep
  bme680.parameter.IIRfilter = 0b100;                  // Setting IIR Filter coefficient to 15 (default)
  bme680.parameter.humidOversampling = 0b101;          // Setting Humidity Oversampling to factor 16 (default)
  bme680.parameter.tempOversampling = 0b101;           // Setting Temperature Oversampling factor to 16 (default)
  bme680.parameter.pressOversampling = 0b000;          // factor 0 = Disable pressure measurement
  if (bme680.init() != 0x61)
  {
    Serial.print(F("BME680 could not be found"));
  }
}

/*****************************************************************CHANNELS******************************************************************/
#define CHANNEL_NAME "Google Cloud IoT Core"
#define Max_Reconnect_Time 30
Helium  helium(&atom_serial);
Channel channel(&helium);
#define PIN_neo1 4                                                              
#define PIN_neo2 7
#define NUMPIXELS 1


int delayval = 500;
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN_neo1, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(NUMPIXELS, PIN_neo2, NEO_GRB + NEO_KHZ800);

void channel_connect() {
  int count = 0;
  helium.begin(9600);
  while (!helium.connected()) {
    //Serial.print("test3");
    neoSetup();
    neoColor(200, 200, 200, 50, pixels2);
    int status = helium.connect();
    report_status(status);
    if (helium_status_OK != status) {
      delay(1000);
    }
    Serial.print("test3");
  }
  
  channel_create(&channel, CHANNEL_NAME);
  neoSetup();
  neoColor(200, 0, 200, 1000, pixels2);
}

void
channel_send(const char * channel_name, void const * data, size_t len)
{
    int    status;
    int8_t result;

    do
    {
        // Try to send
        Serial.print(F("Sending - "));
        status = channel.send(data, len, &result);
        report_status(status, result);
        // Create the channel if any service errors are returned
        if (status == helium_status_OK && result != 0)
        {
            channel_connect();
        }
        else if (status != helium_status_OK)
        {
            delay(1000);
        }
    } while (helium_status_OK != status || result != 0);
}

/****************************************************************JSON STRING****************************************************************/
#define CHANNEL_DELAY 1000
#define CHANNEL_SEND_CYCLE 12
int channel_counter = 0;
double temperature;
double humidity;
double CO_PPM;
int indexing;

void JSONformat(int index) {
 bme680.writeCTRLMeas();
 temperature = bme680.readTempC();
 humidity = bme680.readHumidity();
 CO_PPM=calc_PPM_CO();
 indexing =index;
  if (--channel_counter <= 0)
  {
    StaticJsonBuffer < JSON_OBJECT_SIZE(2) + 100 > jsonBuffer;
    JsonObject & root = jsonBuffer.createObject();

     root[F("Temperature")] = temperature;
    root[F("Humidity")] = humidity;
     root[F("CO_PPM")] =  CO_PPM;
     root[F("index")]  = indexing;

        char   buffer[HELIUM_MAX_DATA_SIZE];
        size_t used = root.printTo(buffer, HELIUM_MAX_DATA_SIZE);

        channel_send(CHANNEL_NAME, buffer, used);

        channel_counter = CHANNEL_SEND_CYCLE;
          }

    delay(CHANNEL_DELAY);
}

/********************************************************************FAN********************************************************************/
#define fan_PIN 13
 
void fan_on(int timedelay) {
  digitalWrite(fan_PIN, LOW);
  delay(timedelay);
  digitalWrite(fan_PIN, HIGH);
  delay(timedelay);
}

/******************************************************************BME680*******************************************************************/
#define buzzer_PIN 6
void buzzerON() {
  pinMode(buzzer_PIN, OUTPUT);
  TCCR0A = 0; //reset the register
  TCCR0B = 0; //reset tthe register
  TCCR0A = 0b10100011; // fast pwm mode
  TCCR0B = 0b00000011; // prescaler 64
  OCR0A = 50; //duty cycle for pin 6
  OCR0B = 50; //duty cycle for pin 5
}


/*****************************************************************NEOPIXEL******************************************************************/
/* This section sets up the neoPixel to display warning lights based on the PPM value.
    The recommended PPM values for dectectable gases are :i) CO --------> < 10 PPM
                                                          ii)H2 --------> < 10 PPM

*/
void neoSetup() {
  pixels.begin();
  pixels2.begin();
}

void neoColor(int R, int G, int B, int wait, Adafruit_NeoPixel pixel) {
  neoSetup();
  pixel.setPixelColor(0, pixel.Color(R, G, B));
  pixel.show();
  delay(wait);
  pixel.setPixelColor(0, pixel.Color(0, 0, 0));
  pixel.show();
  delay(wait);
}

void neoColorPPM(double PPM, Adafruit_NeoPixel pixels) {
  neoSetup();
  if (PPM < 2) {
    pixels.setPixelColor(0, pixels.Color(0, 200, 0));
  }
  else if ((PPM > 2) && (PPM < 5)) {
    neoColor(200, 200, 0, 50, pixels);
  }
  else if (PPM > 5) {
    neoColor(200, 0, 0, 30, pixels);
  }
  pixels.show();
}


/****************************************************************MCIS5524IAQ****************************************************************/

/*The MCIS sensor is sensitive to : i) Carbon Monoxide            (0-100PPM)
                                    ii)Volatile Organic compounds incuding methane (0-1000 PPM)
   At the beginning it is important to place the sensor in a clean air condition so that it can callibrate itself
   Once callibrated the sensor can measure gas resistance at the current conditions.
   The adafruit sensor has a 10 kOhm pulldown at the analog output. The gas resistance RS and the 10Kohm forms a
   voltage dividor and we can calculate RS.
   The ratio RS/RO can be calculated from those values.
   The graph of RS/RO was plotted using the graph from the datasheet and after the graph was linearized using LN the following
   relationship was obtained: i) CO ------> Y = -1.884 X + 1.502 , where Y = ln(PPM) and X = ln(RS/RO)
*/

#define ADC_voltdiv 0.00488
#define Vsupply 5
#define Analog_pulldown 10
#define Ro_correction_factor 0.10
#define eps 50
#define max_Ro_deviation 50
#define Ro_cycles 5

#define CO_threshold 10
#define Ethanol_threshold 80


double Ro_callibrated;
double Rs;
int   Raw_ADCvalue;

double calcRs() {
  Raw_ADCvalue = analogRead(A0);
  Rs = ( ((Vsupply / (ADC_voltdiv * Raw_ADCvalue)) - 1)) * Analog_pulldown;
  return Rs;
}

double recheckCO() {
  double sum;
  double temp_PPM;
  for (int i = 0; i < 5; i++) {
    fan_on(200);
    sum += calc_PPM_CO();
  }
  temp_PPM = sum / 5;
  return temp_PPM;
}
double recheckethanol() {
  double sum;
  double temp_PPM;
  for (int i = 0; i < 5; i++) {
    fan_on(200);
    sum += calc_Ethanol();
  }
  temp_PPM = sum / 5;
  return temp_PPM;
}

double calc_PPM_CO() {
  double ratio = calcRs() / Ro_callibrated;
  double log_ratio = log(ratio);
  double log_PPM   = -1.1884 * (log_ratio) + 1.502;
  double PPM_val = exp(log_PPM);
  Serial.println(PPM_val);
  if (PPM_val > CO_threshold) {
    PPM_val = recheckCO();
    Serial.println((PPM_val));
  }
  if (PPM_val>CO_threshold){
    buzzerON();
    }
  neoColorPPM(PPM_val,pixels);
 
  return PPM_val;
}


double calc_Ethanol() {
  double ratio = calcRs() / Ro_callibrated;
  double log_ratio = log(ratio);
  double log_PPM2   =  -1.53*(log_ratio) + 0.533;
  double PPM_val2 = exp(log_PPM2);
  Serial.println(PPM_val2);
  if (PPM_val2 > Ethanol_threshold) {
    PPM_val2 = recheckethanol();
    Serial.println((PPM_val2));
  }
  if (PPM_val2>Ethanol_threshold){
    buzzerON();
    }
  neoColorPPM(PPM_val2,pixels);
 
  return PPM_val2;
}




boolean Ro_Check() {
  if (abs(Ro_callibrated - max_Ro_deviation) > eps) {
    return false;
  }
  return true;
}

void callibrate_Ro() {
  Ro_callibrated = calcRs() * Ro_correction_factor;
  Serial.println(calcRs());
  Serial.print(("Ro is callibrated at:"));
  Serial.println((Ro_callibrated));
  float sumRo = 0;
  int count = 0;
  while (Ro_Check() == false) {
    Serial.println(("Callibrated value is not within range. Recallibrating...!"));
    for (int i = 0; i++; i < Ro_cycles) {
      fan_on(2000);
      sumRo += calcRs() * Ro_correction_factor;
    }
    delay (1000);
    Ro_callibrated = sumRo / Ro_cycles;
    count++;
    if (count > 10) {
      neoColor(100, 100, 100, 500, pixels);
      Serial.println(F("Please put device in fresh air and restart it!!!."));
      while (1);
    }
  }
}

/*******************************************************************SETUP*******************************************************************/
void setup() {
  
  digitalWrite(fan_PIN,HIGH);
  Serial.begin(9600);
  neoSetup();
  neoColor(0, 0, 200, 1000, pixels2);
  pinMode(fan_PIN,OUTPUT);
  BMEsetup();
  callibrate_Ro();
  channel_connect();
  
}

int count=0;
void loop() {
  count++;
  JSONformat(count);
  delay(500);
}