Adafruit_Wippersnapper_Arduino/html/_wipper_snapper___i2_c___driver_8h_source.html

 #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_LUX:
       _luxSensorPeriod = 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: LUX
    * ****************************/
   /*********************************************************************************/
   /*********************************************************************************/
   virtual long getSensorLuxPeriod() { return _luxSensorPeriod; }

   /*********************************************************************************/
   /*********************************************************************************/
   virtual long getSensorLuxPeriodPrv() { return _luxSensorPeriodPrv; }

   /*******************************************************************************/
   /*******************************************************************************/
   virtual void setSensorLuxPeriodPrv(long period) {
     _luxSensorPeriodPrv = period;
   }

   /*******************************************************************************/
   /*******************************************************************************/
   virtual bool getEventLux(sensors_event_t *luxEvent) {
     (void)luxEvent; // 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 _luxSensorPeriod =
       0L;
   long _luxSensorPeriodPrv = 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
WipperSnapper_I2C_Driver::_unitlessPercentPeriod
long _unitlessPercentPeriod
The time period between reading the unitless % sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1453

WipperSnapper_I2C_Driver::getSensorUnitlessPercentPeriodPrv
virtual long getSensorUnitlessPercentPeriodPrv()
Base implementation - Returns the previous time interval at which the unitless % sensor was queried l...
Definition: WipperSnapper_I2C_Driver.h:851

WipperSnapper_I2C_Driver::getSensorLightPeriodPrv
virtual long getSensorLightPeriodPrv()
Base implementation - Returns the previous time interval at which the light sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:599

WipperSnapper_I2C_Driver::getSensorObjectTempPeriodPrv
virtual long getSensorObjectTempPeriodPrv()
Base implementation - Returns the previous time interval at which the object temperature sensor was q...
Definition: WipperSnapper_I2C_Driver.h:547

WipperSnapper_I2C_Driver::getEventPM10_STD
virtual bool getEventPM10_STD(sensors_event_t *pm10StdEvent)
Base implementation - Reads a object pm10 std. sensor and converts the reading into the expected SI u...
Definition: WipperSnapper_I2C_Driver.h:723

WipperSnapper_I2C_Driver::updateSensorProximity
virtual void updateSensorProximity(float period)
Updates the properties of a proximity sensor.
Definition: WipperSnapper_I2C_Driver.h:1387

WipperSnapper_I2C_Driver::_PM10SensorPeriod
long _PM10SensorPeriod
The time period between reading the pm25 sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1440

WipperSnapper_I2C_Driver::getI2CAddress
uint16_t getI2CAddress()
Gets the I2C device&#39;s address.
Definition: WipperSnapper_I2C_Driver.h:194

WipperSnapper_I2C_Driver::getSensorPM25_STDPeriod
virtual long getSensorPM25_STDPeriod()
Base implementation - Returns the object pm25 standard sensors&#39; period, if set.
Definition: WipperSnapper_I2C_Driver.h:739

WipperSnapper_I2C_Driver::setSensorObjectTempFPeriodPrv
virtual void setSensorObjectTempFPeriodPrv(long period)
Sets a timestamp for when the object temperature sensor (°F) was queried.
Definition: WipperSnapper_I2C_Driver.h:1121

WipperSnapper_I2C_Driver::_PM100SensorPeriod
long _PM100SensorPeriod
The time period between reading the pm100_std sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1448

PERIOD_24HRS_AGO_MILLIS
#define PERIOD_24HRS_AGO_MILLIS
Used for last sensor read time, initially set 24hrs ago (max period)
Definition: WipperSnapper_I2C_Driver.h:24

WipperSnapper_I2C_Driver::setSensorVOCIndexPeriodPrv
virtual void setSensorVOCIndexPeriodPrv(long period)
Sets a timestamp for when the object VOC Index sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:1281

WipperSnapper_I2C_Driver::_currentPeriodPrv
long _currentPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1465

WipperSnapper_I2C_Driver::getSensorPressurePeriod
virtual long getSensorPressurePeriod()
Base implementation - Returns the pressure sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:442

WipperSnapper_I2C_Driver::getSensorTVOCPeriodPrv
virtual long getSensorTVOCPeriodPrv()
Base implementation - Returns the previous time interval at which the TVOC sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:306

WipperSnapper_I2C_Driver::setSensorAmbientTempFPeriodPrv
virtual void setSensorAmbientTempFPeriodPrv(long period)
Sets a timestamp for when the ambient temperature sensor (°F) was queried.
Definition: WipperSnapper_I2C_Driver.h:1065

WipperSnapper_I2C_Driver::getEventPM100_STD
virtual bool getEventPM100_STD(sensors_event_t *pm100StdEvent)
Base implementation - Reads a object pm100 std. sensor and converts the reading into the expected SI ...
Definition: WipperSnapper_I2C_Driver.h:823

WipperSnapper_I2C_Driver::getSensorCurrentPeriod
virtual long getSensorCurrentPeriod()
Base implementation - Returns the current sensor&#39;s period.
Definition: WipperSnapper_I2C_Driver.h:939

WipperSnapper_I2C_Driver::getSensorRelativeHumidityPeriodPrv
virtual long getSensorRelativeHumidityPeriodPrv()
Base implementation - Returns the previous time interval at which the humidity sensor was queried las...
Definition: WipperSnapper_I2C_Driver.h:402

WipperSnapper_I2C_Driver::_altitudeSensorPeriod
long _altitudeSensorPeriod
The time period between reading the altitude sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1421

WipperSnapper_I2C_Driver::getSensorVOCIndexPeriod
virtual long getSensorVOCIndexPeriod()
Base implementation - Returns the VOC Index sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:1260

WipperSnapper_I2C_Driver::getSensorTVOCPeriod
virtual long getSensorTVOCPeriod()
Base implementation - Returns the TVOC sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:297

WipperSnapper_I2C_Driver::setSensorProximityPeriodPrv
virtual void setSensorProximityPeriodPrv(long period)
Sets a timestamp for when the proximity sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:1359

WipperSnapper_I2C_Driver::getEventCO2
virtual bool getEventCO2(sensors_event_t *co2Event)
Gets a sensor&#39;s CO2 value.
Definition: WipperSnapper_I2C_Driver.h:236

WipperSnapper_I2C_Driver::getSensorAmbientTempPeriod
virtual long getSensorAmbientTempPeriod()
Base implementation - Returns the ambient temperature (°C) sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:343

WipperSnapper_I2C_Driver::getSensorPM100_STDPeriodPrv
virtual long getSensorPM100_STDPeriodPrv()
Base implementation - Returns the previous time interval at which the pm100 std. sensor was queried l...
Definition: WipperSnapper_I2C_Driver.h:799

WipperSnapper_I2C_Driver::getSensorAmbientTempPeriodPrv
virtual long getSensorAmbientTempPeriodPrv()
Base implementation - Returns the previous time interval at which the ambient temperature sensor (°C)...
Definition: WipperSnapper_I2C_Driver.h:353

WipperSnapper_I2C_Driver::getEventPM25_STD
virtual bool getEventPM25_STD(sensors_event_t *pm25StdEvent)
Base implementation - Reads a object pm25 std. sensor and converts the reading into the expected SI u...
Definition: WipperSnapper_I2C_Driver.h:773

WipperSnapper_I2C_Driver::getEventNOxIndex
virtual bool getEventNOxIndex(sensors_event_t *gasEvent)
Base implementation - Reads a NOx Index sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:1244

WipperSnapper_I2C_Driver::getSensorECO2PeriodPrv
virtual long getSensorECO2PeriodPrv()
Base implementation - Returns the previous time interval at which the eCO2 sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:260

WipperSnapper_I2C_Driver::_currentPeriod
long _currentPeriod
The time period between reading the current sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1463

WipperSnapper_I2C_Driver::_NOxIndexPeriodPrv
long _NOxIndexPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1489

WipperSnapper_I2C_Driver::_objectTempSensorPeriod
long _objectTempSensorPeriod
Definition: WipperSnapper_I2C_Driver.h:1426

WipperSnapper_I2C_Driver::_TVOCSensorPeriod
long _TVOCSensorPeriod
The time period between reading the TVOC sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1417

WipperSnapper_I2C_Driver::_ambientTempFPeriod
long _ambientTempFPeriod
Definition: WipperSnapper_I2C_Driver.h:1472

WipperSnapper_I2C_Driver::getSensorUnitlessPercentPeriod
virtual long getSensorUnitlessPercentPeriod()
Base implementation - Returns the object unitless % sensor period, if set.
Definition: WipperSnapper_I2C_Driver.h:839

WipperSnapper_I2C_Driver::getSensorCO2Period
virtual long getSensorCO2Period()
Base implementation - Returns the co2 sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:205

WipperSnapper_I2C_Driver::setSensorTVOCPeriodPrv
virtual void setSensorTVOCPeriodPrv(long period)
Sets a timestamp for when the TVOC sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:315

WipperSnapper_I2C_Driver::_VOCIndexPeriodPrv
long _VOCIndexPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1494

WipperSnapper_I2C_Driver::setSensorVoltagePeriodPrv
virtual void setSensorVoltagePeriodPrv(long period)
Sets a timestamp for when the voltage sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:910

WipperSnapper_I2C_Driver::_luxSensorPeriodPrv
long _luxSensorPeriodPrv
sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1438

WipperSnapper_I2C_Driver::setSensorAltitudePeriodPrv
virtual void setSensorAltitudePeriodPrv(long period)
Sets a timestamp for when the Altitude sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:507

WipperSnapper_I2C_Driver::getEventProximity
virtual bool getEventProximity(sensors_event_t *proximityEvent)
Base implementation - Reads a proximity sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:1373

WipperSnapper_I2C_Driver::_tempSensorPeriod
long _tempSensorPeriod
The time period between reading the temperature sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1394

WipperSnapper_I2C_Driver::getEventRelativeHumidity
virtual bool getEventRelativeHumidity(sensors_event_t *humidEvent)
Base implementation - Reads a humidity sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:427

WipperSnapper_I2C_Driver::setSensorNOxIndexPeriodPrv
virtual void setSensorNOxIndexPeriodPrv(long period)
Sets a timestamp for when the object NOx Index sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:1230

WipperSnapper_I2C_Driver::~WipperSnapper_I2C_Driver
virtual ~WipperSnapper_I2C_Driver()
Destructor for an I2C sensor.
Definition: WipperSnapper_I2C_Driver.h:55

WipperSnapper_I2C_Driver::_unitlessPercentPeriodPrv
long _unitlessPercentPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1455

WipperSnapper_I2C_Driver::getSensorAmbientTempFPeriodPrv
virtual long getSensorAmbientTempFPeriodPrv()
Base implementation - Returns the previous time interval at which the ambient temperature sensor (°F)...
Definition: WipperSnapper_I2C_Driver.h:1052

WipperSnapper_I2C_Driver::_voltagePeriod
long _voltagePeriod
The time period between reading the voltage sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1458

WipperSnapper_I2C_Driver::begin
bool begin()
Initializes the I2C sensor and begins I2C.
Definition: WipperSnapper_I2C_Driver.h:78

WipperSnapper_I2C_Driver::getSensorAmbientTempFPeriod
virtual long getSensorAmbientTempFPeriod()
Base implementation - Returns the ambient temperature (°F) sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:1042

WipperSnapper_I2C_Driver::getEventAmbientTempF
virtual bool getEventAmbientTempF(sensors_event_t *AmbientTempFEvent)
Helper function to obtain a sensor&#39;s ambient temperature value in °F. Requires getEventAmbientTemp() ...
Definition: WipperSnapper_I2C_Driver.h:1080

WipperSnapper_I2C_Driver::_TVOCSensorPeriodPrv
long _TVOCSensorPeriodPrv
The time when the TVOC sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1419

WipperSnapper_I2C_Driver::WipperSnapper_I2C_Driver
WipperSnapper_I2C_Driver(TwoWire *i2c, uint16_t sensorAddress)
Instantiates an I2C sensor.
Definition: WipperSnapper_I2C_Driver.h:45

WipperSnapper_I2C_Driver::disableAmbientTempF
virtual void disableAmbientTempF()
Disables the device&#39;s ambient temperature (°F) sensor, if it exists.
Definition: WipperSnapper_I2C_Driver.h:1032

WipperSnapper_I2C_Driver
Base class for I2C Drivers.
Definition: WipperSnapper_I2C_Driver.h:33

WipperSnapper_I2C_Driver::getEventAltitude
virtual bool getEventAltitude(sensors_event_t *altitudeEvent)
Base implementation - Reads a Altitude sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:521

WipperSnapper_I2C_Driver::_pressureSensorPeriod
long _pressureSensorPeriod
The time period between reading the pressure sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1404

WipperSnapper_I2C_Driver::getEventVOCIndex
virtual bool getEventVOCIndex(sensors_event_t *gasEvent)
Base implementation - Reads a VOC Index sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:1295

WipperSnapper_I2C_Driver::getSensorLuxPeriodPrv
virtual long getSensorLuxPeriodPrv()
Base implementation - Returns the previous time interval at which the lux sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:649

WipperSnapper_I2C_Driver::_objectTempFPeriod
long _objectTempFPeriod
Definition: WipperSnapper_I2C_Driver.h:1477

WipperSnapper_I2C_Driver::_ambientTempFPeriodPrv
long _ambientTempFPeriodPrv
was last read.
Definition: WipperSnapper_I2C_Driver.h:1474

WipperSnapper_I2C_Driver::_ECO2SensorPeriodPrv
long _ECO2SensorPeriodPrv
The time when the eCO2 sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1415

WipperSnapper_I2C_Driver::_gasResistancePeriodPrv
long _gasResistancePeriodPrv
last read.
Definition: WipperSnapper_I2C_Driver.h:1484

WipperSnapper_I2C_Driver::_humidSensorPeriod
long _humidSensorPeriod
The time period between reading the humidity sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1399

WipperSnapper_I2C_Driver::setSensorPM100_STDPeriodPrv
virtual void setSensorPM100_STDPeriodPrv(long period)
Sets a timestamp for when the light sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:809

WipperSnapper_I2C_Driver::getSensorLightPeriod
virtual long getSensorLightPeriod()
Base implementation - Returns the object light sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:589

WipperSnapper_I2C_Driver::getEventLux
virtual bool getEventLux(sensors_event_t *luxEvent)
Base implementation - Reads a object Light(lux) sensor and converts the reading into the expected SI ...
Definition: WipperSnapper_I2C_Driver.h:673

WipperSnapper_I2C_Driver::_PM100SensorPeriodPrv
long _PM100SensorPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1450

WipperSnapper_I2C_Driver::getSensorRelativeHumidityPeriod
virtual long getSensorRelativeHumidityPeriod()
Base implementation - Returns the humidity sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:393

WipperSnapper_I2C_Driver::getEventUnitlessPercent
virtual bool getEventUnitlessPercent(sensors_event_t *unitlessPercentEvent)
Base implementation - Reads a object unitless % std. sensor and converts the reading into the expecte...
Definition: WipperSnapper_I2C_Driver.h:877

WipperSnapper_I2C_Driver::getSensorPM25_STDPeriodPrv
virtual long getSensorPM25_STDPeriodPrv()
Base implementation - Returns the previous time interval at which the pm25 std. sensor was queried la...
Definition: WipperSnapper_I2C_Driver.h:749

WipperSnapper_I2C_Driver::getEventTVOC
virtual bool getEventTVOC(sensors_event_t *tvocEvent)
Gets a sensor&#39;s TVOC value.
Definition: WipperSnapper_I2C_Driver.h:328

WipperSnapper_I2C_Driver::_sensorAddress
uint16_t _sensorAddress
The I2C driver&#39;s unique I2C address.
Definition: WipperSnapper_I2C_Driver.h:1393

WipperSnapper_I2C_Driver::getSensorAltitudePeriodPrv
virtual long getSensorAltitudePeriodPrv()
Base implementation - Returns the previous time interval at which the Altitude sensor was queried las...
Definition: WipperSnapper_I2C_Driver.h:498

WipperSnapper_I2C_Driver::_luxSensorPeriod
long _luxSensorPeriod
The time period between reading the lux sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1436

WipperSnapper_I2C_Driver::setSensorECO2PeriodPrv
virtual void setSensorECO2PeriodPrv(long period)
Sets a timestamp for when the eCO2 sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:269

WipperSnapper_I2C_Driver::getSensorGasResistancePeriodPrv
virtual long getSensorGasResistancePeriodPrv()
Base implementation - Returns the previous time interval at which the gas resistance sensor (ohms) wa...
Definition: WipperSnapper_I2C_Driver.h:1166

WipperSnapper_I2C_Driver::_gasResistancePeriod
long _gasResistancePeriod
Definition: WipperSnapper_I2C_Driver.h:1482

WipperSnapper_I2C_Driver::SensorProximityPeriodPrv
virtual long SensorProximityPeriodPrv()
Base implementation - Returns the previous time interval at which the proximity sensor was queried la...
Definition: WipperSnapper_I2C_Driver.h:1349

WipperSnapper_I2C_Driver::getSensorPM100_STDPeriod
virtual long getSensorPM100_STDPeriod()
Base implementation - Returns the object pm100 standard sensors&#39; period, if set.
Definition: WipperSnapper_I2C_Driver.h:789

WipperSnapper_I2C_Driver::_humidSensorPeriodPrv
long _humidSensorPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1401

WipperSnapper_I2C_Driver::getSensorVoltagePeriod
virtual long getSensorVoltagePeriod()
Base implementation - Returns the voltage sensor&#39;s period.
Definition: WipperSnapper_I2C_Driver.h:892

WipperSnapper_I2C_Driver::setSensorPM10_STDPeriodPrv
virtual void setSensorPM10_STDPeriodPrv(long period)
Sets a timestamp for when the light sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:709

WipperSnapper_I2C_Driver::_objectTempSensorPeriodPrv
long _objectTempSensorPeriodPrv
was last read.
Definition: WipperSnapper_I2C_Driver.h:1428

WipperSnapper_I2C_Driver::getSensorPM10_STDPeriodPrv
virtual long getSensorPM10_STDPeriodPrv()
Base implementation - Returns the previous time interval at which the pm10 std. sensor was queried la...
Definition: WipperSnapper_I2C_Driver.h:699

WipperSnapper_I2C_Driver::_objectTempFPeriodPrv
long _objectTempFPeriodPrv
was last read.
Definition: WipperSnapper_I2C_Driver.h:1479

WipperSnapper_I2C_Driver::_lightSensorPeriodPrv
long _lightSensorPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1433

WipperSnapper_I2C_Driver::getEventECO2
virtual bool getEventECO2(sensors_event_t *eco2Event)
Gets a sensor&#39;s eCO2 value.
Definition: WipperSnapper_I2C_Driver.h:282

WipperSnapper_I2C_Driver::setSensorPM25_STDPeriodPrv
virtual void setSensorPM25_STDPeriodPrv(long period)
Sets a timestamp for when the light sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:759

WipperSnapper_I2C_Driver::setSensorPeriod
void setSensorPeriod(float period, wippersnapper_i2c_v1_SensorType sensorType)
Sets the sensor&#39;s period, provided a wippersnapper_i2c_v1_SensorType.
Definition: WipperSnapper_I2C_Driver.h:89

WipperSnapper_I2C_Driver::setSensorObjectTempPeriodPrv
virtual void setSensorObjectTempPeriodPrv(long period)
Sets a timestamp for when the object temperature sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:559

WipperSnapper_I2C_Driver::getSensorPressurePeriodPrv
virtual long getSensorPressurePeriodPrv()
Base implementation - Returns the previous time interval at which the pressure sensor was queried las...
Definition: WipperSnapper_I2C_Driver.h:451

WipperSnapper_I2C_Driver::setSensorPressurePeriodPrv
virtual void setSensorPressurePeriodPrv(long period)
Sets a timestamp for when the pressure sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:460

WipperSnapper_I2C_Driver::setSensorRelativeHumidityPeriodPrv
virtual void setSensorRelativeHumidityPeriodPrv(long periodPrv)
Sets a timestamp for when the temperature sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:413

WipperSnapper_I2C_Driver::getEventPressure
virtual bool getEventPressure(sensors_event_t *pressureEvent)
Base implementation - Reads a pressure sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:474

WipperSnapper_I2C_Driver::getSensorCurrentPeriodPrv
virtual long getSensorCurrentPeriodPrv()
Base implementation - Returns the previous time interval at which the current sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:948

WipperSnapper_I2C_Driver::getSensorGasResistancePeriod
virtual long getSensorGasResistancePeriod()
Base implementation - Returns the gas resistance (ohms) sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:1156

WipperSnapper_I2C_Driver::getSensorAltitudePeriod
virtual long getSensorAltitudePeriod()
Base implementation - Returns the Altitude sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:489

WipperSnapper_I2C_Driver::getEventLight
virtual bool getEventLight(sensors_event_t *lightEvent)
Base implementation - Reads a object light sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:623

WipperSnapper_I2C_Driver::_VOCIndexPeriod
long _VOCIndexPeriod
The time period between reading the VOC Index sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1492

WipperSnapper_I2C_Driver::getEventGasResistance
virtual bool getEventGasResistance(sensors_event_t *gasEvent)
Base implementation - Reads a gas resistance sensor and converts the reading into the expected SI uni...
Definition: WipperSnapper_I2C_Driver.h:1193

WipperSnapper_I2C_Driver::getEventAmbientTemp
virtual bool getEventAmbientTemp(sensors_event_t *tempEvent)
Base implementation - Reads an ambient temperature sensor (°C). Expects value to return in the proper...
Definition: WipperSnapper_I2C_Driver.h:378

WipperSnapper_I2C_Driver::getSensorObjectTempFPeriod
virtual long getSensorObjectTempFPeriod()
Base implementation - Returns the object temperature (°F) sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:1100

WipperSnapper_I2C_Driver::_CO2SensorPeriodPrv
long _CO2SensorPeriodPrv
The time when the CO2 sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1411

WipperSnapper_I2C_Driver::_lightSensorPeriod
long _lightSensorPeriod
The time period between reading the light sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1431

WipperSnapper_I2C_Driver::configureDriver
void configureDriver(wippersnapper_i2c_v1_I2CDeviceInitRequest *msgDeviceInitReq)
Uses an I2CDeviceInitRequest message to configure the sensors belonging to the driver.
Definition: WipperSnapper_I2C_Driver.h:177

WipperSnapper_I2C_Driver::enableSensorProximity
virtual void enableSensorProximity()
Enables the device&#39;s proximity sensor, if it exists.
Definition: WipperSnapper_I2C_Driver.h:1308

WipperSnapper_I2C_Driver::getSensorNOxIndexPeriodPrv
virtual long getSensorNOxIndexPeriodPrv()
Base implementation - Returns the previous time interval at which the NOx Index sensor was queried la...
Definition: WipperSnapper_I2C_Driver.h:1219

WipperSnapper_I2C_Driver::setSensorUnitlessPercentPeriodPrv
virtual void setSensorUnitlessPercentPeriodPrv(long period)
Sets a timestamp for when the unitless % sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:863

WipperSnapper_I2C_Driver::setSensorLuxPeriodPrv
virtual void setSensorLuxPeriodPrv(long period)
Sets a timestamp for when the lux sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:659

WipperSnapper_I2C_Driver::setSensorCO2PeriodPrv
virtual void setSensorCO2PeriodPrv(long period)
Sets a timestamp for when the co2 sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:223

WipperSnapper_I2C_Driver::getSensorRawPeriod
virtual long getSensorRawPeriod()
Base implementation - Returns the raw sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:986

WipperSnapper_I2C_Driver::setSensorRawPeriodPrv
virtual void setSensorRawPeriodPrv(long period)
Sets a timestamp for when the raw sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:1004

WipperSnapper_I2C_Driver::getSensorObjectTempPeriod
virtual long getSensorObjectTempPeriod()
Base implementation - Returns the object temperature sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:537

WipperSnapper_I2C_Driver::setSensorAmbientTempPeriodPrv
virtual void setSensorAmbientTempPeriodPrv(long periodPrv)
Sets a timestamp for when the ambient temperature sensor (°C) was queried.
Definition: WipperSnapper_I2C_Driver.h:364

WipperSnapper_I2C_Driver::_voltagePeriodPrv
long _voltagePeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1460

WipperSnapper_I2C_Driver::_rawSensorPeriod
long _rawSensorPeriod
The time period between reading the Raw sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1468

WipperSnapper_I2C_Driver::getSensorCO2PeriodPrv
virtual long getSensorCO2PeriodPrv()
Base implementation - Returns the previous time interval at which the co2 sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:214

WipperSnapper_I2C_Driver::getSensorECO2Period
virtual long getSensorECO2Period()
Base implementation - Returns the eCO2 sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:251

WipperSnapper_I2C_Driver::disableSensorProximity
virtual void disableSensorProximity()
Disables the device&#39;s object proximity sensor, if it exists.
Definition: WipperSnapper_I2C_Driver.h:1315

WipperSnapper_I2C_Driver::getEventObjectTempF
virtual bool getEventObjectTempF(sensors_event_t *objectTempFEvent)
Helper function to obtain a sensor&#39;s object temperature value in °F. Requires getEventObjectTemp() to...
Definition: WipperSnapper_I2C_Driver.h:1136

WipperSnapper_I2C_Driver::_rawSensorPeriodPrv
long _rawSensorPeriodPrv
The time when the Raw sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1470

WipperSnapper_I2C_Driver::getSensorLuxPeriod
virtual long getSensorLuxPeriod()
Base implementation - Returns the object lux sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:639

WipperSnapper_I2C_Driver::_PM25SensorPeriod
long _PM25SensorPeriod
The time period between reading the pm25 sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1444

WipperSnapper_I2C_Driver::_tempSensorPeriodPrv
long _tempSensorPeriodPrv
last read
Definition: WipperSnapper_I2C_Driver.h:1396

WipperSnapper_I2C_Driver::_PM10SensorPeriodPrv
long _PM10SensorPeriodPrv
The time when the pm25 sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1442

WipperSnapper_I2C_Driver::_CO2SensorPeriod
long _CO2SensorPeriod
The time period between reading the CO2 sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1409

WipperSnapper_I2C_Driver::getSensorPM10_STDPeriod
virtual long getSensorPM10_STDPeriod()
Base implementation - Returns the object pm10 standard sensors&#39; period, if set.
Definition: WipperSnapper_I2C_Driver.h:689

WipperSnapper_I2C_Driver::getSensorObjectTempFPeriodPrv
virtual long getSensorObjectTempFPeriodPrv()
Base implementation - Returns the previous time interval at which the object temperature sensor (°F) ...
Definition: WipperSnapper_I2C_Driver.h:1110

WipperSnapper_I2C_Driver::_proximitySensorPeriodPrv
long _proximitySensorPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1499

WipperSnapper_I2C_Driver::getEventObjectTemp
virtual bool getEventObjectTemp(sensors_event_t *objectTempEvent)
Base implementation - Reads a object temperature sensor and converts the reading into the expected SI...
Definition: WipperSnapper_I2C_Driver.h:573

WipperSnapper_I2C_Driver::getSensorVoltagePeriodPrv
virtual long getSensorVoltagePeriodPrv()
Base implementation - Returns the previous time interval at which the voltage sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:901

WipperSnapper_I2C_Driver::_ECO2SensorPeriod
long _ECO2SensorPeriod
The time period between reading the eCO2 sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1413

WipperSnapper_I2C_Driver::_proximitySensorPeriod
long _proximitySensorPeriod
The time period between reading the proximity sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1497

WipperSnapper_I2C_Driver::getSensorRawPeriodPrv
virtual long getSensorRawPeriodPrv()
Base implementation - Returns the previous time interval at which the raw sensor was queried last...
Definition: WipperSnapper_I2C_Driver.h:995

WipperSnapper_I2C_Driver::setSensorCurrentPeriodPrv
virtual void setSensorCurrentPeriodPrv(long period)
Sets a timestamp for when the current sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:957

WipperSnapper_I2C_Driver::_PM25SensorPeriodPrv
long _PM25SensorPeriodPrv
The time when the pm25 sensor was last read.
Definition: WipperSnapper_I2C_Driver.h:1446

WipperSnapper_I2C_Driver::getEventRaw
virtual bool getEventRaw(sensors_event_t *rawEvent)
Gets a sensor&#39;s Raw value.
Definition: WipperSnapper_I2C_Driver.h:1017

WipperSnapper_I2C_Driver::sensorProximityPeriod
virtual long sensorProximityPeriod()
Base implementation - Returns the proximity sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:1325

WipperSnapper_I2C_Driver::getEventCurrent
virtual bool getEventCurrent(sensors_event_t *currentEvent)
Base implementation - Reads a current sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:971

WipperSnapper_I2C_Driver::setSensorGasResistancePeriodPrv
virtual void setSensorGasResistancePeriodPrv(long period)
Sets a timestamp for when the object gas resistance sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:1179

WipperSnapper_I2C_Driver::_altitudeSensorPeriodPrv
long _altitudeSensorPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1423

WipperSnapper_I2C_Driver::getSensorVOCIndexPeriodPrv
virtual long getSensorVOCIndexPeriodPrv()
Base implementation - Returns the previous time interval at which the VOC Index sensor was queried la...
Definition: WipperSnapper_I2C_Driver.h:1270

WipperSnapper_I2C_Driver::_NOxIndexPeriod
long _NOxIndexPeriod
The time period between reading the NOx Index sensor&#39;s value.
Definition: WipperSnapper_I2C_Driver.h:1487

WipperSnapper_I2C_Driver::getEventVoltage
virtual bool getEventVoltage(sensors_event_t *voltageEvent)
Base implementation - Reads a voltage sensor and converts the reading into the expected SI unit...
Definition: WipperSnapper_I2C_Driver.h:924

WipperSnapper_I2C_Driver::_i2c
TwoWire * _i2c
Pointer to the I2C driver&#39;s Wire object.
Definition: WipperSnapper_I2C_Driver.h:1392

WipperSnapper_I2C_Driver::fastTick
virtual void fastTick()
Lightweight, per-update background hook for drivers that need more frequent internal polling than the...
Definition: WipperSnapper_I2C_Driver.h:70

WipperSnapper_I2C_Driver::_pressureSensorPeriodPrv
long _pressureSensorPeriodPrv
read.
Definition: WipperSnapper_I2C_Driver.h:1406

WipperSnapper_I2C_Driver::getSensorNOxIndexPeriod
virtual long getSensorNOxIndexPeriod()
Base implementation - Returns the NOx Index sensor&#39;s period, if set.
Definition: WipperSnapper_I2C_Driver.h:1209

WipperSnapper_I2C_Driver::setSensorLightPeriodPrv
virtual void setSensorLightPeriodPrv(long period)
Sets a timestamp for when the light sensor was queried.
Definition: WipperSnapper_I2C_Driver.h:609

WipperSnapper_I2C_Driver::setSensorProximityPeriod
virtual void setSensorProximityPeriod(long period)
Set the proximity sensor&#39;s return frequency.
Definition: WipperSnapper_I2C_Driver.h:1335