🚧 WIP, analogio - refactor encode/publish in controller, refactor model

Author: brentru

src/components/analogIO/controller.cpp

@@ -88,13 +88,23 @@ bool AnalogIOController::IsPinTimerExpired(analogioPin *pin, ulong cur_time) {
   return cur_time - pin->prv_period > pin->period;
 }
 
-bool AnalogIOController::EncodePublishPinValue(uint8_t pin, uint16_t value) {
+bool AnalogIOController::EncodePublishPinEvent(
+    uint8_t pin, float value, wippersnapper_sensor_SensorType read_type) {
   char c_pin_name[12];
   sprintf(c_pin_name, "D%d", pin);
 
-  // Encode the DigitalIOEvent message
-  if (!_analogio_model->EncodeAnalogIOEventRaw(c_pin_name, value)) {
-    WS_DEBUG_PRINTLN("ERROR: Unable to encode DigitalIOEvent message!");
+  if (read_type == wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW) {
+    if (!_analogio_model->EncodeAnalogIOEventRaw(c_pin_name, value)) {
+      WS_DEBUG_PRINTLN("ERROR: Unable to encode AnalogIO raw adc message!");
+      return false;
+    }
+  } else if (read_type == wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE) {
+    if (!_analogio_model->EncodeAnalogIOEventVoltage(c_pin_name, value)) {
+      WS_DEBUG_PRINTLN("ERROR: Unable to encode AnalogIO voltage message!");
+      return false;
+    }
+  } else {
+    WS_DEBUG_PRINTLN("ERROR: Invalid read type for AnalogIOEvent message!");
     return false;
   }
 
@@ -111,27 +121,14 @@ bool AnalogIOController::EncodePublishPinValue(uint8_t pin, uint16_t value) {
   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->EncodeAnalogIOEventVoltage(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!")
+bool AnalogIOController::EncodePublishPinValue(uint8_t pin, uint16_t value) {
+  return EncodePublishPinEvent(pin, (float)value,
+                               wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW);
+}
 
-  return true;
+bool AnalogIOController::EncodePublishPinVoltage(uint8_t pin, float value) {
+  return EncodePublishPinEvent(
+      pin, value, wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE);
 }
 
 void AnalogIOController::update() {

src/components/analogIO/controller.h

@@ -50,6 +50,8 @@ class AnalogIOController {
   // Polling loop
   void update();
   // Encoder
+  bool EncodePublishPinEvent(uint8_t pin, float value,
+                             wippersnapper_sensor_SensorType read_type);
   bool EncodePublishPinValue(uint8_t pin, uint16_t value);
   bool EncodePublishPinVoltage(uint8_t pin, float value);
   // Helpers

src/components/analogIO/model.cpp

@@ -54,18 +54,19 @@ wippersnapper_analogio_AnalogIOEvent *AnalogIOModel::GetAnalogIOEvent() {
   return &_msg_AnalogioEvent;
 }
 
-bool AnalogIOModel::EncodeAnalogIOEventRaw(char *pin_name, int16_t pin_value) {
+bool AnalogIOModel::EncodeAnalogIOEvent(
+    char *pin_name, float pin_value,
+    wippersnapper_sensor_SensorType read_type) {
   // 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.type = read_type;
   _msg_AnalogioEvent.sensor_event.which_value =
       wippersnapper_sensor_SensorEvent_float_value_tag;
-  _msg_AnalogioEvent.sensor_event.value.float_value = (float)pin_value;
+  _msg_AnalogioEvent.sensor_event.value.float_value = pin_value;
 
   // Obtain size of an encoded AnalogIOEvent message
   size_t sz_aio_event_msg;
@@ -81,30 +82,13 @@ bool AnalogIOModel::EncodeAnalogIOEventRaw(char *pin_name, int16_t pin_value) {
                    &_msg_AnalogioEvent);
 }
 
+bool AnalogIOModel::EncodeAnalogIOEventRaw(char *pin_name, int16_t pin_value) {
+  return EncodeAnalogIOEvent(pin_name, (float)pin_value,
+                             wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW);
+}
+
 bool AnalogIOModel::EncodeAnalogIOEventVoltage(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_VOLTAGE;
-  _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);
+  return EncodeAnalogIOEvent(
+      pin_name, pin_value, wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE);
 }

src/components/analogIO/model.h

@@ -33,6 +33,8 @@ class AnalogIOModel {
   bool DecodeAnalogIORemove(pb_istream_t *stream);
   wippersnapper_analogio_AnalogIORemove *GetAnalogIORemoveMsg();
   // AnalogIOEvent
+  bool EncodeAnalogIOEvent(char *pin_name, float pin_value,
+                           wippersnapper_sensor_SensorType read_type);
   bool EncodeAnalogIOEventVoltage(char *pin_name, float pin_value);
   bool EncodeAnalogIOEventRaw(char *pin_name, int16_t pin_value);
   wippersnapper_analogio_AnalogIOEvent *GetAnalogIOEvent();