🎨 WIP, analogio - Encode, publish voltage event

Author: brentru

src/components/analogIO/controller.cpp

@@ -40,7 +40,7 @@ bool AnalogIOController::Handle_AnalogIOAdd(pb_istream_t *stream) {
   }
 
   // Get the pin name
-  int pin_name = atoi(_analogio_model->GetAnalogIOAddMsg()->pin_name + 1);
+  uint8_t pin_name = atoi(_analogio_model->GetAnalogIOAddMsg()->pin_name + 1);
 
   // Create a new analogioPin object
   // TODO: Replicate this within the digitalio controller, much cleaner way to
@@ -85,7 +85,35 @@ bool AnalogIOController::Handle_AnalogIORemove(pb_istream_t *stream) {
 }
 
 bool AnalogIOController::IsPinTimerExpired(analogioPin *pin, ulong cur_time) {
-  return cur_time - pin->prv_pin_time > pin->pin_period;
+  return cur_time - pin->prv_period > pin->period;
+}
+
+bool AnalogIOController::EncodePublishPinValue(uint8_t pin, uint16_t value) {
+  // TODO!
+  return true;
+}
+
+bool AnalogIOController::EncodePublishPinVoltage(uint8_t pin, float value) {
+  char c_pin_name[12];
+  sprintf(c_pin_name, "D%d", pin);
+
+  // Encode the DigitalIOEvent message
+  if (!_analogio_model->EncodeAnalogIOVoltageEvent(c_pin_name, value)) {
+    WS_DEBUG_PRINTLN("ERROR: Unable to encode DigitalIOEvent message!");
+    return false;
+  }
+
+  // Publish the DigitalIOEvent message to the broker
+  if (!WsV2.PublishSignal(
+          wippersnapper_signal_DeviceToBroker_digitalio_event_tag,
+          _analogio_model->GetAnalogIOEvent())) {
+    WS_DEBUG_PRINTLN("ERROR: Unable to publish analogio voltage event message, "
+                     "moving onto the next pin!");
+    return false;
+  }
+  WS_DEBUG_PRINTLN("Published AnalogIOEvent message to broker!")
+
+  return true;
 }
 
 void AnalogIOController::update() {
@@ -103,16 +131,17 @@ void AnalogIOController::update() {
       continue;
 
     // Pins timer has expired, lets read the pin
-    if (pin.read_mode == wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE) {
-      // TODO: Read and store the pin's voltage
+    // Read the pin's raw value
+    uint16_t value = _analogio_hardware->GetPinValue(pin.name);
+    if (pin.read_mode == wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW) {
+      // Since we already read the raw value, encode and publish it to the
+      // broker
+      // TODO
     } else if (pin.read_mode ==
-               wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW) {
-      // TODO: Read and store the pin's raw value
-      uint16_t value = _analogio_hardware->GetPinValue(pin.name);
-    } else {
-      WS_DEBUG_PRINT("ERROR: Invalid read mode for analog pin: ");
-      WS_DEBUG_PRINTLN(pin.name);
-      continue;
+               wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE) {
+      // Convert the raw value into voltage
+      float pin_value = _analogio_hardware->CalculatePinVoltage(value);
+      // Encode and publish the voltage value to the broker
     }
   }
 }

src/components/analogIO/controller.h

@@ -44,12 +44,15 @@ class AnalogIOController {
 public:
   AnalogIOController();
   ~AnalogIOController();
-  // Routing functions
+  // Routing
   bool Handle_AnalogIOAdd(pb_istream_t *stream);
   bool Handle_AnalogIORemove(pb_istream_t *stream);
-  // Polling loop function
+  // Polling loop
   void update();
-
+  // Encoder
+  bool EncodePublishPinValue(uint8_t pin, uint16_t value);
+  bool EncodePublishPinVoltage(uint8_t pin, float value);
+  // Helpers
   void SetTotalAnalogPins(uint8_t total_pins);
   void SetRefVoltage(float voltage);
   bool IsPinTimerExpired(analogioPin *pin, ulong cur_time);

src/components/analogIO/hardware.cpp

@@ -55,16 +55,14 @@ void AnalogIOHardware::SetResolution(uint8_t resolution) {
   CalculateScaleFactor();
 }
 
-uint8_t AnalogIOHardware::GetResolution(void) { return _adc_resolution; }
-
 void AnalogIOHardware::CalculateScaleFactor() {
   if (!_is_adc_resolution_scaled)
     return;
 
-  if (getADCresolution() > getNativeResolution()) {
-    _scale_factor = getADCresolution() - getNativeResolution();
+  if (_adc_resolution > _native_adc_resolution) {
+    _scale_factor = _adc_resolution - _native_adc_resolution;
   } else {
-    _scale_factor = getNativeResolution() - getADCresolution();
+    _scale_factor = _native_adc_resolution - _adc_resolution;
   }
 }
 
@@ -73,7 +71,7 @@ uint16_t AnalogIOHardware::GetPinValue(uint8_t pin) {
   uint16_t value = analogRead(pin);
   // Scale the pins value
   if (_is_adc_resolution_scaled) {
-    if (getADCresolution() > getNativeResolution()) {
+    if (_adc_resolution > _native_adc_resolution) {
       value = value << _scale_factor;
     } else {
       value = value >> _scale_factor;
@@ -82,8 +80,7 @@ uint16_t AnalogIOHardware::GetPinValue(uint8_t pin) {
   return value;
 }
 
-float Wippersnapper_AnalogIO::GetPinVoltage(uint8_t pin) {
-  uint16_t raw_value = GetPinValue(pin);
+float AnalogIOHardware::CalculatePinVoltage(uint16_t raw_value) {
   float voltage = raw_value * _voltage_scale_factor;
-  return voltage
+  return voltage;
 }

src/components/analogIO/hardware.h

@@ -27,15 +27,14 @@ class AnalogIOHardware {
   ~AnalogIOHardware();
   void SetNativeADCResolution();
   void SetResolution(uint8_t resolution);
-  uint8_t GetResolution(void);
   void SetReferenceVoltage(float voltage);
   void CalculateScaleFactor();
 
   // Arduino/Wiring API
   void InitPin(uint8_t pin);
   void DeinitPin(uint8_t pin);
   uint16_t GetPinValue(uint8_t pin);
-  float GetPinVoltage(uint8_t pin);
+  float CalculatePinVoltage(uint16_t raw_voltage);
 
 private:
   uint8_t _native_adc_resolution;

src/components/analogIO/model.cpp

@@ -48,4 +48,36 @@ bool AnalogIOModel::DecodeAnalogIORemove(pb_istream_t *stream) {
 
 wippersnapper_analogio_AnalogIORemove *AnalogIOModel::GetAnalogIORemoveMsg() {
   return &_msg_AnalogioRemove;
+}
+
+wippersnapper_analogio_AnalogIOEvent *AnalogIOModel::GetAnalogIOEvent() {
+  return &_msg_AnalogioEvent;
+}
+
+bool AnalogIOModel::EncodeAnalogIOVoltageEvent(char *pin_name,
+                                               float pin_value) {
+  // Initialize the AnalogIOEvent message to default values
+  _msg_AnalogioEvent = wippersnapper_analogio_AnalogIOEvent_init_zero;
+  // Fill the AnalogIOEvent message's fields
+  strncpy(_msg_AnalogioEvent.pin_name, pin_name,
+          sizeof(_msg_AnalogioEvent.pin_name));
+  _msg_AnalogioEvent.has_sensor_event = true;
+  _msg_AnalogioEvent.sensor_event.type =
+      wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW;
+  _msg_AnalogioEvent.sensor_event.which_value =
+      wippersnapper_sensor_SensorEvent_float_value_tag;
+  _msg_AnalogioEvent.sensor_event.value.float_value = pin_value;
+
+  // Obtain size of an encoded AnalogIOEvent message
+  size_t sz_aio_event_msg;
+  if (!pb_get_encoded_size(&sz_aio_event_msg,
+                           wippersnapper_analogio_AnalogIOEvent_fields,
+                           &_msg_AnalogioEvent))
+    return false;
+
+  // Encode the AnalogIOEvent message
+  uint8_t buf[sz_aio_event_msg];
+  pb_ostream_t msg_stream = pb_ostream_from_buffer(buf, sizeof(buf));
+  return pb_encode(&msg_stream, wippersnapper_analogio_AnalogIOEvent_fields,
+                   &_msg_AnalogioEvent);
 }

src/components/analogIO/model.h

@@ -32,9 +32,14 @@ class AnalogIOModel {
   // AnalogIORemove
   bool DecodeAnalogIORemove(pb_istream_t *stream);
   wippersnapper_analogio_AnalogIORemove *GetAnalogIORemoveMsg();
+  // AnalogIOEvent
+  bool EncodeAnalogIOVoltageEvent(char *pin_name, float pin_value);
+  // bool EncodeAnalogIORawEvent(char *pin_name, int16_t pin_value);
+  wippersnapper_analogio_AnalogIOEvent *GetAnalogIOEvent();
 
 private:
   wippersnapper_analogio_AnalogIOAdd _msg_AnalogioAdd;
   wippersnapper_analogio_AnalogIORemove _msg_AnalogioRemove;
+  wippersnapper_analogio_AnalogIOEvent _msg_AnalogioEvent;
 };
 #endif // WS_DIGITALIO_MODEL_H