WIP on master: 0848a13 Add photoresistor support

3 files changed, 456 insertions, 52 deletions

diff --git a/src/main/CCS811.cpp b/src/main/CCS811.cpp
new file mode 100644
index 0000000..05b71c0
--- /dev/null
+++ b/src/main/CCS811.cpp
@@ -0,0 +1,154 @@
+#include "CCS811.h"
+
+int CCS811::begin(void)
+{
+    uint8_t id=0;
+    Wire.begin();
+    softReset();
+    delay(100);
+    if(readReg(CCS811_REG_HW_ID,&id,1) != 1){DBG("");
+        DBG("bus data access error");DBG("");
+        return ERR_DATA_BUS;DBG("");
+    }
+
+    DBG("real sensor id=");DBG(id);
+    if(id != CCS811_HW_ID){DBG("");
+        delay(1);
+        return ERR_IC_VERSION;
+    }
+    writeReg(CCS811_BOOTLOADER_APP_START, NULL, 0);
+    setMeasurementMode(0,0,eMode4);
+    setInTempHum(25, 50);
+    return ERR_OK;
+}
+
+void CCS811::softReset(){
+    uint8_t value[4] = {0x11, 0xE5, 0x72, 0x8A};
+    writeReg(CCS811_REG_SW_RESET, value, 4);
+}
+
+bool CCS811::checkDataReady()
+{
+    int8_t status[1] = {0};
+    readReg(CCS811_REG_STATUS, status, 1);
+    DBG(status[0],HEX);
+    if(!((status[0] >> 3) & 0x01))
+        return false;
+    else 
+        return true;
+}
+
+uint16_t CCS811::readBaseLine(){
+    uint8_t buffer[2];
+    readReg(CCS811_REG_BASELINE, buffer, 2);
+    return buffer[0]<<8|buffer[1];
+}
+
+void CCS811::writeBaseLine(uint16_t baseLine){
+    uint8_t buffer[2];
+    
+    buffer[0] = baseLine>>8;
+    buffer[1] = baseLine;
+    writeReg(CCS811_REG_BASELINE, buffer, 2);
+}
+
+void CCS811::setMeasurementMode(uint8_t thresh, uint8_t interrupt, eDRIVE_MODE_t mode){
+    uint8_t measurement[1] = {0};
+    measurement[0] = (thresh << 2) | (interrupt << 3) | (mode << 4);
+    writeReg(CCS811_REG_MEAS_MODE, measurement, 1);
+}
+
+void CCS811::setMeasCycle(eCycle_t cycle){
+    uint8_t measurement[1] = {0};   
+    measurement[0] = cycle << 4;
+    writeReg(CCS811_REG_MEAS_MODE, measurement, 1);
+}
+
+uint8_t CCS811::getMeasurementMode(){
+    uint8_t meas[1] = {0};
+    readReg(CCS811_REG_MEAS_MODE, meas, 1);
+    return meas[0];
+}
+
+void CCS811::setThresholds(uint16_t lowToMed, uint16_t medToHigh)
+{
+    uint8_t buffer[] = {(uint8_t)((lowToMed >> 8) & 0xF),
+                        (uint8_t)(lowToMed & 0xF),
+                        (uint8_t)((medToHigh >> 8) & 0xF),
+                        (uint8_t)(medToHigh & 0xF)};
+    
+    writeReg(CCS811_REG_THRESHOLDS, buffer, 5);
+    uint8_t buf[1];
+    readReg(CCS811_REG_THRESHOLDS, buf, 1);
+    Serial.println(buf[0],HEX);
+}
+
+uint16_t CCS811::getCO2PPM(){
+    uint8_t buffer[8];
+    readReg(CCS811_REG_ALG_RESULT_DATA, buffer, 8);
+    eCO2 = (((uint16_t)buffer[0] << 8) | (uint16_t)buffer[1]);
+    return eCO2;
+}
+
+uint16_t CCS811::getTVOCPPB(){
+    uint8_t buffer[8];
+    readReg(CCS811_REG_ALG_RESULT_DATA, buffer, 8);
+    eTVOC = (((uint16_t)buffer[2] << 8) | (uint16_t)buffer[3]);
+    return eTVOC;
+}
+
+void CCS811::setInTempHum(float temperature, float humidity)    // compensate for temperature and relative humidity
+{
+    int _temp, _rh;
+    if(temperature>0)
+        _temp = (int)temperature + 0.5;  // this will round off the floating point to the nearest integer value
+    else if(temperature<0) // account for negative temperatures
+        _temp = (int)temperature - 0.5;
+    _temp = _temp + 25;  // temperature high byte is stored as T+25°C in the sensor's memory so the value of byte is positive
+    _rh = (int)humidity + 0.5;  // this will round off the floating point to the nearest integer value
+    
+    uint8_t envData[4];
+    
+    envData[0] = _rh << 1;  // shift the binary number to left by 1. This is stored as a 7-bit value
+    envData[1] = 0;  // most significant fractional bit. Using 0 here - gives us accuracy of +/-1%. Current firmware (2016) only supports fractional increments of 0.5
+    envData[2] = _temp << 1;
+    envData[3] = 0;
+    
+    writeReg(CCS811_REG_ENV_DATA, &envData, 4);
+}
+
+void CCS811::writeReg(uint8_t reg, const void* pBuf, size_t size)
+{
+    if(pBuf == NULL){
+        DBG("pBuf ERROR!! : null pointer");
+    }
+    uint8_t * _pBuf = (uint8_t *)pBuf;
+    _pWire->beginTransmission(_deviceAddr);
+    _pWire->write(&reg, 1);
+    
+    for(uint16_t i = 0; i < size; i++){
+        _pWire->write(_pBuf[i]);
+    }
+    _pWire->endTransmission();
+}
+
+uint8_t CCS811::readReg(uint8_t reg, const void* pBuf, size_t size)
+{
+    if(pBuf == NULL){
+        DBG("pBuf ERROR!! : null pointer");
+    }
+    uint8_t * _pBuf = (uint8_t *)pBuf;
+    _pWire->beginTransmission(_deviceAddr);
+    _pWire->write(&reg, 1);
+    
+    if( _pWire->endTransmission() != 0){
+        return 0;
+    }
+
+    _pWire->requestFrom(_deviceAddr, (uint8_t) size);
+    for(uint16_t i = 0; i < size; i++){
+        _pBuf[i] = _pWire->read();
+    }
+    _pWire->endTransmission();
+    return size;
+}

diff --git a/src/main/CCS811.h b/src/main/CCS811.h
new file mode 100644
index 0000000..2640535
--- /dev/null
+++ b/src/main/CCS811.h
@@ -0,0 +1,224 @@
+#ifndef _CCS811_H
+#define _CCS811_H
+
+#if ARDUINO >= 100
+#include "Arduino.h"
+#else
+#include "WProgram.h"
+#endif
+#include <Wire.h>
+
+
+/*I2C ADDRESS*/
+#define CCS811_I2C_ADDRESS1                      0x5A
+#define CCS811_I2C_ADDRESS2                      0x5B
+
+#define CCS811_REG_STATUS                        0x00
+#define CCS811_REG_MEAS_MODE                     0x01
+#define CCS811_REG_ALG_RESULT_DATA               0x02
+#define CCS811_REG_RAW_DATA                      0x03
+#define CCS811_REG_ENV_DATA                      0x05
+#define CCS811_REG_NTC                           0x06
+#define CCS811_REG_THRESHOLDS                    0x10
+#define CCS811_REG_BASELINE                      0x11
+#define CCS811_REG_HW_ID                         0x20
+#define CCS811_REG_HW_VERSION                    0x21
+#define CCS811_REG_FW_BOOT_VERSION               0x23
+#define CCS811_REG_FW_APP_VERSION                0x24
+#define CCS811_REG_INTERNAL_STATE                0xA0
+#define CCS811_REG_ERROR_ID                      0xE0
+#define CCS811_REG_SW_RESET                      0xFF
+
+#define CCS811_BOOTLOADER_APP_ERASE              0xF1
+#define CCS811_BOOTLOADER_APP_DATA               0xF2
+#define CCS811_BOOTLOADER_APP_VERIFY             0xF3
+#define CCS811_BOOTLOADER_APP_START              0xF4
+
+#define CCS811_HW_ID                             0x81
+//Open the macro to see the detailed program execution process.
+//#define ENABLE_DBG
+
+#ifdef ENABLE_DBG
+#define DBG(...) {Serial.print("[");Serial.print(__FUNCTION__); Serial.print("(): "); Serial.print(__LINE__); Serial.print(" ] "); Serial.println(__VA_ARGS__);}
+#else
+#define DBG(...)
+#endif
+
+class CCS811
+{
+public:
+    #define ERR_OK             0      //OK 
+    #define ERR_DATA_BUS      -1      //error in data bus
+    #define ERR_IC_VERSION    -2      //chip version mismatch
+    
+    uint8_t _deviceAddr;
+    typedef enum{
+        eMode0, //Idle (Measurements are disabled in this mode)
+        eMode1, //Constant power mode, IAQ measurement every second
+        eMode2, //Pulse heating mode IAQ measurement every 10 seconds
+        eMode3, //Low power pulse heating mode IAQ measurement every 60 seconds
+        eMode4  //Constant power mode, sensor measurement every 250ms 1xx: Reserved modes (For future use)
+    }eDRIVE_MODE_t;
+    
+    typedef enum{
+        eClosed,      //Idle (Measurements are disabled in this mode)
+        eCycle_1s,    //Constant power mode, IAQ measurement every second
+        eCycle_10s,   //Pulse heating mode IAQ measurement every 10 seconds
+        eCycle_60s,   //Low power pulse heating mode IAQ measurement every 60 seconds
+        eCycle_250ms  //Constant power mode, sensor measurement every 250ms 1xx: Reserved modes (For future use)
+    }eCycle_t;
+    /**
+     * @brief Constructor 
+     * @param Input in Wire address
+     */
+    CCS811(TwoWire *pWire = &Wire, uint8_t deviceAddr = 0x5A){_pWire = pWire; _deviceAddr = deviceAddr;};
+    
+              /**
+               * @brief Constructor
+               * @return Return 0 if initialization succeeds, otherwise return non-zero.
+               */
+    int       begin();
+              /**
+               * @brief Judge if there is data to read 
+               * @return Return 1 if there is, otherwise return 0. 
+               */
+    bool      checkDataReady();
+              /**
+               * @brief Reset sensor, clear all configured data.
+               */
+    void      softReset(),
+              /**
+               * @brief Set environment parameter 
+               * @param temperature Set temperature value, unit: centigrade, range (-40~85℃)
+               * @param humidity    Set humidity value, unit: RH, range (0~100)
+               */
+              setInTempHum(float temperature, float humidity),
+              /**
+               * @brief Measurement parameter configuration 
+               * @param thresh:0 for Interrupt mode operates normally; 1 for interrupt mode only asserts the nINT signal (driven low) if the new
+               * @param interrupt:0 for Interrupt generation is disabled; 1 for the nINT signal is asserted (driven low) when a new sample is ready in
+               * @param mode:in typedef enum eDRIVE_MODE_t
+               */
+              setMeasurementMode(uint8_t thresh, uint8_t interrupt, eDRIVE_MODE_t mode),
+              /**
+               * @brief Measurement parameter configuration 
+               * @param mode:in typedef enum eDRIVE_MODE_t
+               */
+              setMeasCycle(eCycle_t cycle),
+              /**
+               * @brief Set interrupt thresholds 
+               * @param lowToMed: interrupt triggered value in range low to middle 
+               * @param medToHigh: interrupt triggered value in range middle to high 
+               */
+              setThresholds(uint16_t lowToMed, uint16_t medToHigh);
+              /**
+               * @brief Get current configured parameter
+               * @return configuration code, needs to be converted into binary code to analyze
+               *         The 2nd: Interrupt mode (if enabled) operates normally,1: Interrupt mode (if enabled) only asserts the nINT signal (driven low) if the new
+               *         The 3rd: Interrupt generation is disabled,1: The nINT signal is asserted (driven low) when a new sample is ready in
+               *         The 4th: 6th: in typedef enum eDRIVE_MODE_t
+               */
+    uint8_t   getMeasurementMode();
+
+              /**
+               * @brief Get the current carbon dioxide concentration
+               * @return current carbon dioxide concentration, unit:ppm
+               */
+    uint16_t  getCO2PPM(),
+              /**
+               * @brief Get current TVOC concentration
+               * @return Return current TVOC concentration, unit: ppb
+               */
+              getTVOCPPB();
+    uint16_t  readBaseLine();
+    void      writeBaseLine(uint16_t baseLine);
+    
+protected:
+
+    typedef struct{
+        /*
+         * The CCS811 received an I²C write request addressed to this station but with invalid register address ID
+         */
+        uint8_t sWRITE_REG_INVALID: 1;
+        /*
+         * The CCS811 received an I²C read request to a mailbox ID that is invalid
+         */
+        uint8_t sREAD_REG_INVALID: 1;
+        /*
+         * The CCS811 received an I²C request to write an unsupported mode to MEAS_MODE
+         */
+        uint8_t sMEASMODE_INVALID: 1;
+        /*
+         * The sensor resistance measurement has reached or exceeded the maximum range
+         */
+        uint8_t sMAX_RESISTANCE: 1;
+        /*
+         * The The Heater current in the CCS811 is not in range
+         */
+        uint8_t sHEATER_FAULT: 1;
+        /*
+         * The Heater voltage is not being applied correctly
+         */
+        uint8_t sHEATER_SUPPLY: 1;
+    } __attribute__ ((packed))sError_id;
+    
+    typedef struct{
+        /* 
+         * ALG_RESULT_DATA crosses one of the thresholds set in the THRESHOLDS register 
+         * by more than the hysteresis value (also in the THRESHOLDS register)
+         */
+        uint8_t sINT_THRESH: 1;
+        /* 
+         * At the end of each measurement cycle (250ms, 1s, 10s, 60s) a flag is set in the
+         * STATUS register regardless of the setting of this bit.
+         */
+        uint8_t sINT_DATARDY: 1;
+        /* 
+         * A new sample is placed in ALG_RESULT_DATA and RAW_DATA registers and the
+         * DATA_READY bit in the STATUS register is set at the defined measurement interval.
+         */
+        uint8_t sDRIVE_MODE: 3;
+    } __attribute__ ((packed))sMeas_mode;
+    
+    typedef struct{
+        /* 
+         * This bit is cleared by reading ERROR_ID
+         * It is not sufficient to read the ERROR field of ALG_RESULT_DATA and STATUS
+         */
+        uint8_t sERROR: 1;
+        /* 
+         * ALG_RESULT_DATA is read on the I²C interface
+         */
+        uint8_t sDATA_READY: 1;
+        uint8_t sAPP_VALID: 1;
+        /* 
+         * After issuing a VERIFY command the application software must wait 70ms before 
+         * issuing any transactions to CCS811 over the I²C interface
+         */
+        uint8_t sAPP_VERIFY: 1;
+        /* 
+         * After issuing the ERASE command the application software must wait 500ms 
+         * before issuing any transactions to the CCS811 over the I2C interface.
+         */
+        uint8_t sAPP_ERASE: 1;
+        uint8_t sFW_MODE: 1;
+    } __attribute__ ((packed))sStatus;
+    
+    
+    void getData(void);
+    
+    void writeConfig();
+         
+    virtual void writeReg(uint8_t reg, const void* pBuf, size_t size);
+    virtual uint8_t readReg(uint8_t reg, const void* pBuf, size_t size);
+    
+    
+
+private:
+    TwoWire *_pWire;
+    
+    uint16_t eCO2;
+    uint16_t eTVOC;
+};
+
+#endif

diff --git a/src/main/main.ino b/src/main/main.ino
index a435473..e29a174 100644
--- a/src/main/main.ino
+++ b/src/main/main.ino
@@ -1,3 +1,8 @@
+#include <DHT.h>
+#include "ota.h"
+#include <WiFiClient.h>
+#include "CCS811.h"
+
 #define TEMP_SENSOR_PIN 12
 #define HUMIDITY_SENSOR_PIN 12
 #define FAN_PIN 15
@@ -10,35 +15,52 @@
 #define HUMIDITY_DESIRED 75
 #define HUMIDITY_VARIATION 3   // ultrasonic turns on at (75 - 3 = 72) and off
                                // at (75 + 3 = 78)
-
-#include "ota.h"
-
-#include <WiFiClient.h>
 WiFiClient *wific = 0;
 
 // Tempature + Humidity Sensor
-#include <DHT.h>
 #define DHTPIN 12
 #define DHTTYPE DHT11
 DHT dht(DHTPIN, DHTTYPE);
 
+/*
+ * IIC address default 0x5A, the address becomes 0x5B if the ADDR_SEL is soldered.
+ */
+//CCS811 sensor(&Wire, /*IIC_ADDRESS=*/0x5A);
+CCS811 sensor;
 
-void setup () {
-  Serial.begin(115200);
-  Serial.println(F("Mushing..."));
-
+void setup(void)
+{
   setupWifi((char *) hostname);
   setupOTA((char *) hostname);
 
   dht.begin();                    // temp+humidity sensor
   pinMode(PHOTORESISTOR, INPUT);  // photo resistor
   wific = new WiFiClient();
+
+
+  Serial.begin(115200);
+  /*Wait for the chip to be initialized completely, and then exit*/
+  while(sensor.begin() != 0){
+    Serial.println("failed to init chip, please check if the chip connection is fine");
+    delay(1000);
+  }
+  /**
+   * @brief Set measurement cycle
+   * @param cycle:in typedef enum{
+   *                  eClosed,      //Idle (Measurements are disabled in this mode)
+   *                  eCycle_1s,    //Constant power mode, IAQ measurement every second
+   *                  Ecycle_10s,   //Pulse heating mode IAQ measurement every 10 seconds
+   *                  eCycle_60s,   //Low power pulse heating mode IAQ measurement every 60 seconds
+   *                  eCycle_250ms  //Constant power mode, sensor measurement every 250ms
+   *                  }eCycle_t;
+   */
+  sensor.setMeasCycle(sensor.eCycle_250ms);
 }
 
-void log_reading ( float temp_c, float humidity, float heat_index_c, int photons ) {
-  auto fmt = "T: %.2f H: %.2f HI: %.2f LIGHT: %d\r\n";
+void log_reading ( float temp_c, float humidity, float heat_index_c, int photons,  uint16_t co2, uint16_t tvoc ) {
+  auto fmt = "T: %.2f H: %.2f HI: %.2f Light: %d CO2: %d TVOC: %d\r\n";
   char buf[500];
-  snprintf(buf, sizeof(buf), fmt, temp_c, humidity, heat_index_c, photons);
+  snprintf(buf, sizeof(buf), fmt, temp_c, humidity, heat_index_c, photons, co2, tvoc);
   //Serial.printf(fmt, temp_c, humidity, heat_index_c);
   Serial.print(buf);
   if (wific->connected()) {
@@ -46,46 +68,50 @@ void log_reading ( float temp_c, float humidity, float heat_index_c, int photons
   }
 }
 
-/*
-Global state variables to hold rolling average humidity, temperature, etc sensor values
-Override state variable is set by network command
-
-Need max and min threshhold values for each sensor too
-
-struct SensorState
-{
-  float rolling_average;
-  float threshold_top;
-  float threshold_bottom;
-  void *top_exceeded_callback();
-  float force_value;
-}
-*/
-
 void loop() {
-  ArduinoOTA.handle();
+  uint16_t co2, tvoc;
+
+  delay(1000);
+    if(sensor.checkDataReady() == true){
+      co2 = sensor.getCO2PPM();
+      tvoc = sensor.getTVOCPPB();
+        // Serial.print("CO2: ");
+        // Serial.print(sensor.getCO2PPM());
+        // Serial.print("ppm, TVOC: ");
+        // Serial.print(sensor.getTVOCPPB());
+        // Serial.println("ppb");
+    } else {
+        Serial.println("Data is not ready!");
+    }
+    /*!
+     * @brief Set baseline
+     * @param get from getBaseline.ino
+     */
+    sensor.writeBaseLine(0x847B);
+    //delay cannot be less than measurement cycle
+    //delay(1000);
+
+    ArduinoOTA.handle();
+
+    auto ip = IPAddress(192,168,1,2);
+    auto port = 3141;
+    if (!wific->connected()) {
+      Serial.println("Attempting to connect");
+      wific->connect(ip, port);
+    }
+
+    // Wait a few seconds between measurements.
+
+    float hum = dht.readHumidity();
+    float temp = dht.readTemperature();
+    // Check if any reads failed and exit early (to try again).
+    if (isnan(hum) || isnan(temp) ) {
+      Serial.println(F("Failed to read from DHT sensor!"));
+      return;
+    }
+    float hic = dht.computeHeatIndex(temp, hum, false);
+
+    int photons = analogRead(PHOTORESISTOR);
+    log_reading(temp, hum, hic, photons, co2, tvoc);
 
-
-  auto ip = IPAddress(192,168,1,2);
-  auto port = 3141;
-  if (!wific->connected()) {
-    Serial.println("Attempting to connect");
-    wific->connect(ip, port);
-  }
-
-  // Wait a few seconds between measurements.
-  delay(2000);
-
-  float h = dht.readHumidity();
-  float t = dht.readTemperature();
-  // Check if any reads failed and exit early (to try again).
-  if (isnan(h) || isnan(t) ) {
-    Serial.println(F("Failed to read from DHT sensor!"));
-    return;
-  }
-  float hic = dht.computeHeatIndex(t, h, false);
-
-  int photons = analogRead(PHOTORESISTOR);
-  log_reading(t, h, hic, photons);
 }
-