WipperSnapper_I2C_Driver.h

Go to the documentation of this file.

#ifndef WipperSnapper_I2C_Driver_H
#define WipperSnapper_I2C_Driver_H

#include "wippersnapper/i2c/v1/i2c.pb.h"
#include <Adafruit_Sensor.h>
#include <Arduino.h>
#include <Wire.h>

#define PERIOD_24HRS_AGO_MILLIS (millis() - (24 * 60 * 60 * 1000))
#define ONE_SECOND_IN_MILLIS 1000 

/**************************************************************************/
/**************************************************************************/
class WipperSnapper_I2C_Driver {

public:
  /*******************************************************************************/
  /*******************************************************************************/
  WipperSnapper_I2C_Driver(TwoWire *i2c, uint16_t sensorAddress) {
    _i2c = i2c;
    _sensorAddress = sensorAddress;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual ~WipperSnapper_I2C_Driver() {}

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void fastTick() {}

  /*******************************************************************************/
  /*******************************************************************************/
  bool begin() { return false; }

  /*******************************************************************************/
  /*******************************************************************************/
  void setSensorPeriod(float period,
                       wippersnapper_i2c_v1_SensorType sensorType) {
    long sensorPeriod = (long)period * 1000;

    switch (sensorType) {
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_AMBIENT_TEMPERATURE:
      _tempSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_RELATIVE_HUMIDITY:
      _humidSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_PRESSURE:
      _pressureSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_CO2:
      _CO2SensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_ECO2:
      _ECO2SensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_TVOC:
      _TVOCSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_ALTITUDE:
      _altitudeSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_OBJECT_TEMPERATURE:
      _objectTempSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_LIGHT:
      _lightSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_PM10_STD:
      _PM10SensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_PM25_STD:
      _PM25SensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_PM100_STD:
      _PM100SensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_UNITLESS_PERCENT:
      _unitlessPercentPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_VOLTAGE:
      _voltagePeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_CURRENT:
      _currentPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_PROXIMITY:
      _proximitySensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_RAW:
      _rawSensorPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_AMBIENT_TEMPERATURE_FAHRENHEIT:
      _ambientTempFPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_OBJECT_TEMPERATURE_FAHRENHEIT:
      _objectTempFPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_GAS_RESISTANCE:
      _gasResistancePeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_NOX_INDEX:
      _NOxIndexPeriod = sensorPeriod;
      break;
    case wippersnapper_i2c_v1_SensorType_SENSOR_TYPE_VOC_INDEX:
      _VOCIndexPeriod = sensorPeriod;
      break;
    default:
      break;
    }
  }

  /*******************************************************************************/
  /*******************************************************************************/
  void
  configureDriver(wippersnapper_i2c_v1_I2CDeviceInitRequest *msgDeviceInitReq) {
    int propertyIdx = 0; // contains the amount of i2c sensors in the
                         // msgDeviceInitReq to configure
    while (propertyIdx < msgDeviceInitReq->i2c_device_properties_count) {
      setSensorPeriod(
          msgDeviceInitReq->i2c_device_properties[propertyIdx].sensor_period,
          msgDeviceInitReq->i2c_device_properties[propertyIdx].sensor_type);
      ++propertyIdx;
    }
  }

  /*******************************************************************************/
  /*******************************************************************************/
  uint16_t getI2CAddress() { return _sensorAddress; }

  /****************************** SENSOR_TYPE: CO2
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorCO2Period() { return _CO2SensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorCO2PeriodPrv() { return _CO2SensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorCO2PeriodPrv(long period) {
    _CO2SensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventCO2(sensors_event_t *co2Event) {
    (void)
        co2Event; // Parameter is intentionally unused in this virtual function.
    return false;
  }

  /****************************** SENSOR_TYPE: ECO2
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorECO2Period() { return _ECO2SensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorECO2PeriodPrv() { return _ECO2SensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorECO2PeriodPrv(long period) {
    _ECO2SensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventECO2(sensors_event_t *eco2Event) {
    (void)eco2Event; // Parameter is intentionally unused in this virtual
                     // function.
    return false;
  }

  /****************************** SENSOR_TYPE: TVOC
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorTVOCPeriod() { return _TVOCSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorTVOCPeriodPrv() { return _TVOCSensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorTVOCPeriodPrv(long period) {
    _TVOCSensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventTVOC(sensors_event_t *tvocEvent) {
    (void)tvocEvent; // Parameter is intentionally unused in this virtual
                     // function.
    return false;
  }

  /********************** SENSOR_TYPE: AMBIENT TEMPERATURE (°C)
   * ***********************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorAmbientTempPeriod() { return _tempSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorAmbientTempPeriodPrv() { return _tempSensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorAmbientTempPeriodPrv(long periodPrv) {
    _tempSensorPeriodPrv = periodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventAmbientTemp(sensors_event_t *tempEvent) {
    (void)tempEvent; // Parameter is intentionally unused in this virtual
                     // function.
    return false;
  }

  /************************* SENSOR_TYPE: RELATIVE_HUMIDITY
   * ***********************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorRelativeHumidityPeriod() { return _humidSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorRelativeHumidityPeriodPrv() {
    return _humidSensorPeriodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorRelativeHumidityPeriodPrv(long periodPrv) {
    _humidSensorPeriodPrv = periodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventRelativeHumidity(sensors_event_t *humidEvent) {
    (void)humidEvent; // Parameter is intentionally unused in this virtual
                      // function.
    return false;
  }

  /**************************** SENSOR_TYPE: PRESSURE
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPressurePeriod() { return _pressureSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPressurePeriodPrv() { return _pressureSensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorPressurePeriodPrv(long period) {
    _pressureSensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventPressure(sensors_event_t *pressureEvent) {
    (void)pressureEvent; // Parameter is intentionally unused in this virtual
                         // function.
    return false;
  }

  /**************************** SENSOR_TYPE: Altitude
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorAltitudePeriod() { return _altitudeSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorAltitudePeriodPrv() { return _altitudeSensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorAltitudePeriodPrv(long period) {
    _altitudeSensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventAltitude(sensors_event_t *altitudeEvent) {
    (void)altitudeEvent; // Parameter is intentionally unused in this virtual
                         // function.
    return false;
  }

  /**************************** SENSOR_TYPE: Object_Temperature
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorObjectTempPeriod() { return _objectTempSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorObjectTempPeriodPrv() {
    return _objectTempSensorPeriodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorObjectTempPeriodPrv(long period) {
    _objectTempSensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventObjectTemp(sensors_event_t *objectTempEvent) {
    (void)objectTempEvent; // Parameter is intentionally unused in this virtual
                           // function.
    return false;
  }

  /**************************** SENSOR_TYPE: LIGHT
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorLightPeriod() { return _lightSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorLightPeriodPrv() { return _lightSensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorLightPeriodPrv(long period) {
    _lightSensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventLight(sensors_event_t *lightEvent) {
    (void)lightEvent; // Parameter is intentionally unused in this virtual
                      // function.
    return false;
  }

  /**************************** SENSOR_TYPE: PM10_STD
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPM10_STDPeriod() { return _PM10SensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPM10_STDPeriodPrv() { return _PM10SensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorPM10_STDPeriodPrv(long period) {
    _PM10SensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventPM10_STD(sensors_event_t *pm10StdEvent) {
    (void)pm10StdEvent; // Parameter is intentionally unused in this virtual
                        // function.
    return false;
  }

  /**************************** SENSOR_TYPE: PM25_STD
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPM25_STDPeriod() { return _PM25SensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPM25_STDPeriodPrv() { return _PM25SensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorPM25_STDPeriodPrv(long period) {
    _PM25SensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventPM25_STD(sensors_event_t *pm25StdEvent) {
    (void)pm25StdEvent; // Parameter is intentionally unused in this virtual
                        // function.
    return false;
  }

  /**************************** SENSOR_TYPE: PM100_STD
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPM100_STDPeriod() { return _PM100SensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorPM100_STDPeriodPrv() { return _PM100SensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorPM100_STDPeriodPrv(long period) {
    _PM100SensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventPM100_STD(sensors_event_t *pm100StdEvent) {
    (void)pm100StdEvent; // Parameter is intentionally unused in this virtual
                         // function.
    return false;
  }

  /**************************** SENSOR_TYPE: UNITLESS_PERCENT
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorUnitlessPercentPeriod() {
    return _unitlessPercentPeriod;
  }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorUnitlessPercentPeriodPrv() {
    return _unitlessPercentPeriodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorUnitlessPercentPeriodPrv(long period) {
    _unitlessPercentPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventUnitlessPercent(sensors_event_t *unitlessPercentEvent) {
    (void)unitlessPercentEvent; // Parameter is intentionally unused in this
                                // virtual function.
    return false;
  }

  /**************************** SENSOR_TYPE: VOLTAGE
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorVoltagePeriod() { return _voltagePeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorVoltagePeriodPrv() { return _voltagePeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorVoltagePeriodPrv(long period) {
    _voltagePeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventVoltage(sensors_event_t *voltageEvent) {
    (void)voltageEvent; // Parameter is intentionally unused in this virtual
                        // function.
    return false;
  }

  /**************************** SENSOR_TYPE: CURRENT
   * ****************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorCurrentPeriod() { return _currentPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorCurrentPeriodPrv() { return _currentPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorCurrentPeriodPrv(long period) {
    _currentPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventCurrent(sensors_event_t *currentEvent) {
    (void)currentEvent; // Parameter is intentionally unused in this virtual
                        // function.
    return false;
  }

  /****************************** SENSOR_TYPE: Raw
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorRawPeriod() { return _rawSensorPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorRawPeriodPrv() { return _rawSensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorRawPeriodPrv(long period) {
    _rawSensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventRaw(sensors_event_t *rawEvent) {
    (void)
        rawEvent; // Parameter is intentionally unused in this virtual function.
    return false;
  }

  /****************************** SENSOR_TYPE: Ambient Temp (°F)
   * *******************************/

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void disableAmbientTempF() { _ambientTempFPeriod = 0.0L; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorAmbientTempFPeriod() { return _ambientTempFPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorAmbientTempFPeriodPrv() {
    return _ambientTempFPeriodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorAmbientTempFPeriodPrv(long period) {
    _ambientTempFPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventAmbientTempF(sensors_event_t *AmbientTempFEvent) {
    // obtain ambient temp. in °C
    if (!getEventAmbientTemp(AmbientTempFEvent))
      return false;
    // convert event from °C to °F
    AmbientTempFEvent->temperature =
        (AmbientTempFEvent->temperature * 9.0) / 5.0 + 32;
    return true;
  }

  /****************************** SENSOR_TYPE: Object Temp (°F)
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorObjectTempFPeriod() { return _objectTempFPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorObjectTempFPeriodPrv() { return _objectTempFPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorObjectTempFPeriodPrv(long period) {
    _objectTempFPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventObjectTempF(sensors_event_t *objectTempFEvent) {
    // obtain ambient temp. in °C
    if (!getEventObjectTemp(objectTempFEvent))
      return false;
    // convert event from °C to °F
    objectTempFEvent->temperature =
        (objectTempFEvent->temperature * 9.0) / 5.0 + 32.0;
    return true;
  }

  /****************************** SENSOR_TYPE: Gas Resistance (ohms)
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorGasResistancePeriod() { return _gasResistancePeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorGasResistancePeriodPrv() {
    return _gasResistancePeriodPrv;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorGasResistancePeriodPrv(long period) {
    _gasResistancePeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventGasResistance(sensors_event_t *gasEvent) {
    (void)
        gasEvent; // Parameter is intentionally unused in this virtual function.
    return false;
  }

  /****************************** SENSOR_TYPE: NOx Index (index)
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorNOxIndexPeriod() { return _NOxIndexPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorNOxIndexPeriodPrv() { return _NOxIndexPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorNOxIndexPeriodPrv(long period) {
    _NOxIndexPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventNOxIndex(sensors_event_t *gasEvent) {
    (void)
        gasEvent; // Parameter is intentionally unused in this virtual function.
    return false;
  }

  /****************************** SENSOR_TYPE: VOC Index (index)
   * *******************************/
  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorVOCIndexPeriod() { return _VOCIndexPeriod; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long getSensorVOCIndexPeriodPrv() { return _VOCIndexPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorVOCIndexPeriodPrv(long period) {
    _VOCIndexPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventVOCIndex(sensors_event_t *gasEvent) {
    (void)
        gasEvent; // Parameter is intentionally unused in this virtual function.
    return false;
  }

  /**************************** SENSOR_TYPE: PROXIMITY
   * ****************************/
  /*******************************************************************************/
  /*******************************************************************************/
  virtual void enableSensorProximity() {};

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void disableSensorProximity() { _proximitySensorPeriod = 0.0L; }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long sensorProximityPeriod() { return _proximitySensorPeriod; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorProximityPeriod(long period) {
    if (period == 0)
      disableSensorProximity();
    _proximitySensorPeriod = period;
  }

  /*********************************************************************************/
  /*********************************************************************************/
  virtual long SensorProximityPeriodPrv() { return _proximitySensorPeriodPrv; }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void setSensorProximityPeriodPrv(long period) {
    _proximitySensorPeriodPrv = period;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual bool getEventProximity(sensors_event_t *proximityEvent) {
    (void)proximityEvent; // Parameter is intentionally unused in this virtual
                          // function.
    return false;
  }

  /*******************************************************************************/
  /*******************************************************************************/
  virtual void updateSensorProximity(float period) {
    setSensorProximityPeriod(period);
  }

protected:
  TwoWire *_i2c;           
  uint16_t _sensorAddress; 
  long _tempSensorPeriod =
      0L; 
  long _tempSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _humidSensorPeriod =
      0L; 
  long _humidSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _pressureSensorPeriod =
      0L; 
  long _pressureSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _CO2SensorPeriod =
      0L; 
  long _CO2SensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _ECO2SensorPeriod =
      0L; 
  long _ECO2SensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _TVOCSensorPeriod =
      0L; 
  long _TVOCSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _altitudeSensorPeriod =
      0L; 
  long _altitudeSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _objectTempSensorPeriod = 0L; 
  long _objectTempSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _lightSensorPeriod =
      0L; 
  long _lightSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _PM10SensorPeriod =
      0L; 
  long _PM10SensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _PM25SensorPeriod =
      0L; 
  long _PM25SensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _PM100SensorPeriod =
      0L; 
  long _PM100SensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _unitlessPercentPeriod =
      0L; 
  long _unitlessPercentPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _voltagePeriod =
      0L; 
  long _voltagePeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _currentPeriod =
      0L; 
  long _currentPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _rawSensorPeriod =
      0L; 
  long _rawSensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _ambientTempFPeriod = 0L; 
  long _ambientTempFPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _objectTempFPeriod = 0L; 
  long _objectTempFPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _gasResistancePeriod = 0L; 
  long _gasResistancePeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _NOxIndexPeriod =
      0L; 
  long _NOxIndexPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _VOCIndexPeriod =
      0L; 
  long _VOCIndexPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
  long _proximitySensorPeriod =
      0L; 
  long _proximitySensorPeriodPrv =
      PERIOD_24HRS_AGO_MILLIS; 
};

#endif // WipperSnapper_I2C_Driver_H