Merge pull request #173 from adafruit/i2c-init

Add I2C Device Initialization

Author: brentru

src/Wippersnapper.cpp

@@ -560,12 +560,12 @@ bool cbDecodeSignalRequestI2C(pb_istream_t *stream, const pb_field_t *field,
       is_success = false;
     }
 
-    // Pack I2CResponse message
+    // Fill I2CResponse
     msgi2cResponse.which_payload =
         wippersnapper_signal_v1_I2CRequest_req_i2c_init_tag;
     msgi2cResponse.payload.resp_i2c_init.is_initialized = is_success;
 
-    // Encode I2CResponse message
+    // Encode I2CResponse
     if (!encodeI2CResponse(&msgi2cResponse)) {
       return false;
     }
@@ -602,15 +602,14 @@ bool cbDecodeSignalRequestI2C(pb_istream_t *stream, const pb_field_t *field,
     WS_DEBUG_PRINT("\t# of addresses found on bus: ");
     WS_DEBUG_PRINTLN(scanResp.addresses_found_count);
 
-    // Pack I2CResponse
+    // Fill I2CResponse
     msgi2cResponse.which_payload =
         wippersnapper_signal_v1_I2CResponse_resp_i2c_scan_tag;
     memcpy(msgi2cResponse.payload.resp_i2c_scan.addresses_found,
            scanResp.addresses_found, sizeof(scanResp.addresses_found));
     msgi2cResponse.payload.resp_i2c_scan.addresses_found_count =
         scanResp.addresses_found_count;
-
-    // Encode I2C Response
+    // Encode I2CResponse
     if (!encodeI2CResponse(&msgi2cResponse)) {
       return false;
     }
@@ -626,30 +625,57 @@ bool cbDecodeSignalRequestI2C(pb_istream_t *stream, const pb_field_t *field,
       WS_DEBUG_PRINTLN("ERROR: Could not decode I2CDeviceInitRequest message.");
       return false; // fail out if we can't decode
     }
-    // Attach device to I2C port
-    bool deviceInitSuccess = false;
+
+    // Create response
+    msgi2cResponse = wippersnapper_signal_v1_I2CResponse_init_zero;
+    msgi2cResponse.which_payload =
+        wippersnapper_signal_v1_I2CResponse_resp_i2c_device_init_tag;
+
+    // Initialize device and fill response
     if (msgI2CDeviceInitRequest.i2c_port_number == 0 &&
         WS._i2cPort0->isInitialized() == true) {
-      deviceInitSuccess =
-          WS._i2cPort0->attachI2CDevice(&msgI2CDeviceInitRequest);
+      msgi2cResponse.payload.resp_i2c_device_init.is_success =
+          WS._i2cPort0->initI2CDevice(&msgI2CDeviceInitRequest);
     } else if (msgI2CDeviceInitRequest.i2c_port_number == 1 &&
                WS._i2cPort1->isInitialized() == true) {
-      deviceInitSuccess =
-          WS._i2cPort1->attachI2CDevice(&msgI2CDeviceInitRequest);
+      msgi2cResponse.payload.resp_i2c_device_init.is_success =
+          WS._i2cPort1->initI2CDevice(&msgI2CDeviceInitRequest);
     }
-    // Create response
+
+    // Encode response
+    if (!encodeI2CResponse(&msgi2cResponse)) {
+      return false;
+    }
+
+  } else if (field->tag ==
+             wippersnapper_signal_v1_I2CRequest_req_i2c_device_deinit_tag) {
+    WS_DEBUG_PRINTLN("NEW COMMAND: I2C Device De-init");
+    // Decode stream into an I2CDeviceDeinitRequest
+    wippersnapper_i2c_v1_I2CDeviceDeinitRequest msgI2CDeviceDeinitRequest =
+        wippersnapper_i2c_v1_I2CDeviceDeinitRequest_init_zero;
+    // Decode stream into struct, msgI2CDeviceDeinitRequest
+    if (!pb_decode(stream, wippersnapper_i2c_v1_I2CDeviceDeinitRequest_fields,
+                   &msgI2CDeviceDeinitRequest)) {
+      WS_DEBUG_PRINTLN(
+          "ERROR: Could not decode I2CDeviceDeinitRequest message.");
+      return false; // fail out if we can't decode
+    }
+
+    // Empty I2C response to fill out
     msgi2cResponse = wippersnapper_signal_v1_I2CResponse_init_zero;
     msgi2cResponse.which_payload =
-        wippersnapper_signal_v1_I2CResponse_resp_i2c_device_init_tag;
-    msgi2cResponse.payload.resp_i2c_device_init.is_success = deviceInitSuccess;
-    // Encode message
-    memset(WS._buffer_outgoing, 0, sizeof(WS._buffer_outgoing));
-    pb_ostream_t ostream = pb_ostream_from_buffer(WS._buffer_outgoing,
-                                                  sizeof(WS._buffer_outgoing));
-    if (!pb_encode(&ostream, wippersnapper_signal_v1_I2CResponse_fields,
-                   &msgi2cResponse)) {
-      WS_DEBUG_PRINTLN("ERROR: Unable to encode I2C response message");
-      return false; // fail out if we cant encode
+        wippersnapper_signal_v1_I2CResponse_resp_i2c_device_deinit_tag;
+
+    // Delete device from I2C bus
+    if (msgI2CDeviceDeinitRequest.i2c_port_number == 0 &&
+        WS._i2cPort0->isInitialized() == true) {
+      msgi2cResponse.payload.resp_i2c_device_deinit.is_success =
+          WS._i2cPort0->deinitI2CDevice(&msgI2CDeviceDeinitRequest);
+    }
+
+    // Encode response
+    if (!encodeI2CResponse(&msgi2cResponse)) {
+      return false;
     }
   } else {
     WS_DEBUG_PRINTLN("ERROR: Undefined I2C message tag");
@@ -1492,7 +1518,6 @@ ws_status_t Wippersnapper::run() {
   WS._mqtt->processPackets(10);
   feedWDT();
 
-  // TODO: Loop thru components
   // Process digital inputs, digitalGPIO module
   WS._digitalGPIO->processDigitalInputs();
   feedWDT();
@@ -1501,5 +1526,9 @@ ws_status_t Wippersnapper::run() {
   WS._analogIO->processAnalogInputs();
   feedWDT();
 
+  // Process I2C sensor events
+  // WS._i2cPort0->update();
+  // feedWDT();
+
   return WS_NET_CONNECTED; // TODO: Make this funcn void!
 }

src/Wippersnapper.h

@@ -56,9 +56,7 @@
 
 // Uncomment the following use the staging IO server //
 //#define USE_STAGING                     ///< Use Adafruit IO staging
-// certificate #define IO_MQTT_SERVER "io.adafruit.us" ///< Adafruit IO MQTT
-// Server
-
+// certificate
 #define IO_MQTT_SERVER "io.adafruit.com" ///< Adafruit IO MQTT Server
 //(Production)
 
@@ -71,7 +69,7 @@
 #endif
 
 #define WS_VERSION                                                             \
-  "1.0.0-beta.14" ///< WipperSnapper app. version (semver-formatted)
+  "1.0.0-beta.15" ///< WipperSnapper app. version (semver-formatted)
 
 // Reserved Adafruit IO MQTT topics
 #define TOPIC_IO_THROTTLE "/throttle" ///< Adafruit IO Throttle MQTT Topic

src/components/i2c/WipperSnapper_I2C.cpp

@@ -113,49 +113,125 @@ WipperSnapper_Component_I2C::scanAddresses() {
 
 /*******************************************************************************/
 /*!
-    @brief    Initializes I2C device driver and attaches its object to the "bus"
+    @brief    Initializes I2C device driver.
     @param    msgDeviceInitReq
               A decoded I2CDevice initialization request message.
     @returns True if I2C device is initialized and attached, False otherwise.
 */
 /*******************************************************************************/
-bool WipperSnapper_Component_I2C::attachI2CDevice(
+bool WipperSnapper_Component_I2C::initI2CDevice(
     wippersnapper_i2c_v1_I2CDeviceInitRequest *msgDeviceInitReq) {
-  bool attachSuccess = false;
-  // Determine which sensor-specific callback to utilize
 
-  // AHTX0 Sensor
+  uint16_t i2cAddress = (uint16_t)msgDeviceInitReq->i2c_address;
+  // Determine which sensor-specific callback to utilize
   if (msgDeviceInitReq->has_aht_init) {
-    // TODO: Implement handling in future release
-    /*     uint16_t addr = (uint16_t)msgDeviceInitReq->aht_init.address;
-        WS_DEBUG_PRINTLN("Requesting to initialize AHTx sensor");
-        WS_DEBUG_PRINT("\tSensor Addr: ");
-        WS_DEBUG_PRINTLN(addr, HEX);
-        WS_DEBUG_PRINT("\tTemperature sensor enabled? ");
-        WS_DEBUG_PRINTLN(msgDeviceInitReq->aht_init.enable_temperature);
-        WS_DEBUG_PRINT("\tHumidity sensor enabled? ");
-        WS_DEBUG_PRINTLN(msgDeviceInitReq->aht_init.enable_humidity);
-
-        // TODO: Create I2C Driver using the an AHT driver sub-class!
-        I2C_Driver *aht = new I2C_Driver(addr, this->_i2c);
-        // Attempt to initialize the sensor driver
-        if (!aht->initAHTX0()) {
-          attachSuccess = false;
-          return attachSuccess;
-        }
-        // Initialize device-specific sensors
-        if (msgDeviceInitReq->aht_init.enable_temperature == true) {
-          aht->enableAHTX0Temperature();
-        }
-        if (msgDeviceInitReq->aht_init.enable_humidity == true) {
-          aht->enableAHTX0Humidity();
-        }
-        // Push to vector for sensor drivers
-        activeDrivers.push_back(aht); */
-    attachSuccess = true;
+    // Initialize new AHTX0 sensor
+    _ahtx0 = new WipperSnapper_I2C_Driver_AHTX0(this->_i2c, i2cAddress);
+
+    // Did we initialize successfully?
+    if (!_ahtx0->getInitialized()) {
+      WS_DEBUG_PRINTLN("ERROR: Failed to initialize AHTX0 chip!");
+      return false;
+    }
+    WS_DEBUG_PRINTLN("AHTX0 Initialized Successfully!");
+
+    // Configure AHTX0 sensor
+    if (msgDeviceInitReq->aht_init.enable_temperature) {
+      _ahtx0->enableTemperatureSensor();
+      _ahtx0->setTemperatureSensorPeriod(
+          msgDeviceInitReq->aht_init.period_temperature);
+      WS_DEBUG_PRINTLN("Enabled AHTX0 Temperature Sensor, [Returns every: ");
+      WS_DEBUG_PRINT(msgDeviceInitReq->aht_init.period_temperature);
+      WS_DEBUG_PRINTLN("seconds]");
+    }
+    if (msgDeviceInitReq->aht_init.enable_humidity) {
+      _ahtx0->enableHumiditySensor();
+      _ahtx0->setHumiditySensorPeriod(
+          msgDeviceInitReq->aht_init.period_humidity);
+      WS_DEBUG_PRINTLN("Enabled AHTX0 Humidity Sensor, [Returns every: ");
+      WS_DEBUG_PRINT(msgDeviceInitReq->aht_init.period_humidity);
+      WS_DEBUG_PRINTLN("seconds]");
+    }
+    drivers.push_back(_ahtx0);
   } else {
     WS_DEBUG_PRINTLN("ERROR: Sensor not found")
   }
   WS_DEBUG_PRINTLN("Successfully initialized AHTX0 sensor!");
-  return attachSuccess;
+  return true;
+}
+
+/*******************************************************************************/
+/*!
+    @brief    Updates the properties of an I2C device driver.
+    @param    msgDeviceUpdateReq
+              A decoded I2CDeviceUpdateRequest.
+    @returns True if I2C device is was successfully updated, False otherwise.
+*/
+/*******************************************************************************/
+bool WipperSnapper_Component_I2C::updateI2CDevice(
+    wippersnapper_i2c_v1_I2CDeviceDeinitRequest *msgDeviceUpdateReq) {
+  // TODO!! //
+}
+
+/*******************************************************************************/
+/*!
+    @brief    Deinitializes an I2C device driver.
+    @param    msgDeviceDeinitReq
+              A decoded I2CDeviceDeinitRequest.
+    @returns True if I2C device is found and de-initialized, False otherwise.
+*/
+/*******************************************************************************/
+bool WipperSnapper_Component_I2C::deinitI2CDevice(
+    wippersnapper_i2c_v1_I2CDeviceDeinitRequest *msgDeviceDeinitReq) {
+  uint16_t deviceAddr = (uint16_t)msgDeviceDeinitReq->i2c_address;
+  // Loop thru vector of drivers
+  for (int i = 0; i < drivers.size(); i++) {
+    if (drivers[i]->getSensorAddress() == deviceAddr) {
+      // Check driver type
+      if (drivers[i]->getDriverType() == AHTX0) {
+        // Should we delete the driver entirely, or just update?
+        if ((msgDeviceDeinitReq->aht.disable_temperature &&
+             drivers[i]->getHumidSensorPeriod() == -1L) ||
+            (msgDeviceDeinitReq->aht.disable_humidity &&
+             drivers[i]->getTempSensorPeriod() == -1L) ||
+            (msgDeviceDeinitReq->aht.disable_temperature &&
+             msgDeviceDeinitReq->aht.disable_humidity)) {
+          // delete the driver and remove from list so we dont attempt to
+          // update() it
+          delete _ahtx0;
+          drivers.erase(drivers.begin() + i);
+          return true;
+          WS_DEBUG_PRINTLN("AHTX0 Deleted");
+        }
+
+        // Disable the device's temperature sensor
+        else if (msgDeviceDeinitReq->aht.disable_temperature) {
+          drivers[i]->disableTemperatureSensor();
+          return true;
+          WS_DEBUG_PRINTLN("AHTX0 Temperature Sensor Disabled");
+        }
+
+        // Disable the device's humidity sensor
+        else if (msgDeviceDeinitReq->aht.disable_humidity) {
+          drivers[i]->disableHumiditySensor();
+          WS_DEBUG_PRINTLN("AHTX0 Humidity Sensor Disabled");
+          return true;
+        }
+      } else {
+        WS_DEBUG_PRINTLN("ERROR: Driver type unspecified");
+      }
+    }
+  }
+  // Driver was not erased or not found
+  return false;
+}
+
+/*******************************************************************************/
+/*!
+    @brief    Queries all I2C device drivers for new values. Fills and sends an
+              I2CSensorEvent with the sensor event data.
+*/
+/*******************************************************************************/
+void WipperSnapper_Component_I2C::update() {
+  // TODO
 }

src/components/i2c/WipperSnapper_I2C.h

@@ -19,11 +19,11 @@
 #include "Wippersnapper.h"
 #include <Wire.h>
 
-#include "drivers/I2C_Driver.h"
+#include "drivers/WipperSnapper_I2C_Driver.h"
+#include "drivers/WipperSnapper_I2C_Driver_AHTX0.h"
 
 // forward decl.
 class Wippersnapper;
-class I2C_Driver;
 
 /**************************************************************************/
 /*!
@@ -35,16 +35,27 @@ class WipperSnapper_Component_I2C {
   WipperSnapper_Component_I2C(
       wippersnapper_i2c_v1_I2CBusInitRequest *msgInitRequest);
   ~WipperSnapper_Component_I2C();
+  bool isInitialized();
+
   wippersnapper_i2c_v1_I2CBusScanResponse scanAddresses();
   bool
-  attachI2CDevice(wippersnapper_i2c_v1_I2CDeviceInitRequest *msgDeviceInitReq);
-  bool isInitialized();
+  initI2CDevice(wippersnapper_i2c_v1_I2CDeviceInitRequest *msgDeviceInitReq);
+  // TODO: Update Implementation
+  // THIS NEEDS AN UPDATE REQUEST
+  bool updateI2CDevice(
+      wippersnapper_i2c_v1_I2CDeviceDeinitRequest *msgDeviceUpdateReq);
+  bool deinitI2CDevice(
+      wippersnapper_i2c_v1_I2CDeviceDeinitRequest *msgDeviceDeinitReq);
+
+  void update();
 
 private:
   bool _isInit;
   int32_t _portNum;
-  TwoWire *_i2c = NULL;
-  std::vector<I2C_Driver *> activeDrivers;
+  TwoWire *_i2c = nullptr;
+  std::vector<WipperSnapper_I2C_Driver *> drivers;
+  // Sensor drivers
+  WipperSnapper_I2C_Driver_AHTX0 *_ahtx0 = nullptr;
 };
 extern Wippersnapper WS;