From 19ea463cec128664b25974274e42d284cffec560 Mon Sep 17 00:00:00 2001 From: brentru Date: Fri, 7 Nov 2025 15:40:57 -0500 Subject: [PATCH 1/7] Add Protos - bold experiments 0ca9424 --- src/protos/analogio.pb.c | 6 + src/protos/analogio.pb.h | 50 ++++++- src/protos/checkin.pb.c | 12 ++ src/protos/checkin.pb.h | 147 +++++++++++++++++- src/protos/digitalio.pb.c | 6 + src/protos/digitalio.pb.h | 63 +++++++- src/protos/ds18x20.pb.c | 6 + src/protos/ds18x20.pb.h | 55 ++++++- src/protos/gps.pb.c | 6 + src/protos/gps.pb.h | 41 +++++- src/protos/i2c.pb.c | 6 + src/protos/i2c.pb.h | 71 +++++++++ src/protos/pixels.pb.c | 6 + src/protos/pixels.pb.h | 54 ++++++- src/protos/pwm.pb.c | 12 +- src/protos/pwm.pb.h | 130 +++++++++------- src/protos/servo.pb.c | 6 + src/protos/servo.pb.h | 52 ++++++- src/protos/signal.pb.h | 303 ++++++++++++-------------------------- src/protos/uart.pb.c | 6 + src/protos/uart.pb.h | 128 ++++++++++++---- 21 files changed, 847 insertions(+), 319 deletions(-) diff --git a/src/protos/analogio.pb.c b/src/protos/analogio.pb.c index 1e29a849b..e62a1bb6f 100644 --- a/src/protos/analogio.pb.c +++ b/src/protos/analogio.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_analogio_AnalogIOB2D, wippersnapper_analogio_AnalogIOB2D, AUTO) + + +PB_BIND(wippersnapper_analogio_AnalogIOD2B, wippersnapper_analogio_AnalogIOD2B, AUTO) + + PB_BIND(wippersnapper_analogio_AnalogIOAdd, wippersnapper_analogio_AnalogIOAdd, AUTO) diff --git a/src/protos/analogio.pb.h b/src/protos/analogio.pb.h index 6fe6b246b..26bb2f69e 100644 --- a/src/protos/analogio.pb.h +++ b/src/protos/analogio.pb.h @@ -25,6 +25,16 @@ typedef struct _wippersnapper_analogio_AnalogIORemove { char pin_name[64]; /* * Name of the pin. */ } wippersnapper_analogio_AnalogIORemove; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_analogio_AnalogIOB2D { + pb_size_t which_payload; + union { + wippersnapper_analogio_AnalogIOAdd analogio_add; + wippersnapper_analogio_AnalogIORemove analogio_remove; + } payload; +} wippersnapper_analogio_AnalogIOB2D; + /* * AnalogIOEvent is contains a value, sent when an analog pin is read. */ typedef struct _wippersnapper_analogio_AnalogIOEvent { @@ -33,15 +43,28 @@ typedef struct _wippersnapper_analogio_AnalogIOEvent { wippersnapper_sensor_SensorEvent sensor_event; /* * Reading(s) from an analog pin. */ } wippersnapper_analogio_AnalogIOEvent; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_analogio_AnalogIOD2B { + pb_size_t which_payload; + union { + wippersnapper_analogio_AnalogIOEvent analogio_event; + } payload; +} wippersnapper_analogio_AnalogIOD2B; + #ifdef __cplusplus extern "C" { #endif /* Initializer values for message structs */ +#define wippersnapper_analogio_AnalogIOB2D_init_default {0, {wippersnapper_analogio_AnalogIOAdd_init_default}} +#define wippersnapper_analogio_AnalogIOD2B_init_default {0, {wippersnapper_analogio_AnalogIOEvent_init_default}} #define wippersnapper_analogio_AnalogIOAdd_init_default {"", 0, _wippersnapper_sensor_SensorType_MIN} #define wippersnapper_analogio_AnalogIORemove_init_default {""} #define wippersnapper_analogio_AnalogIOEvent_init_default {"", false, wippersnapper_sensor_SensorEvent_init_default} +#define wippersnapper_analogio_AnalogIOB2D_init_zero {0, {wippersnapper_analogio_AnalogIOAdd_init_zero}} +#define wippersnapper_analogio_AnalogIOD2B_init_zero {0, {wippersnapper_analogio_AnalogIOEvent_init_zero}} #define wippersnapper_analogio_AnalogIOAdd_init_zero {"", 0, _wippersnapper_sensor_SensorType_MIN} #define wippersnapper_analogio_AnalogIORemove_init_zero {""} #define wippersnapper_analogio_AnalogIOEvent_init_zero {"", false, wippersnapper_sensor_SensorEvent_init_zero} @@ -51,10 +74,27 @@ extern "C" { #define wippersnapper_analogio_AnalogIOAdd_period_tag 2 #define wippersnapper_analogio_AnalogIOAdd_read_mode_tag 3 #define wippersnapper_analogio_AnalogIORemove_pin_name_tag 1 +#define wippersnapper_analogio_AnalogIOB2D_analogio_add_tag 10 +#define wippersnapper_analogio_AnalogIOB2D_analogio_remove_tag 11 #define wippersnapper_analogio_AnalogIOEvent_pin_name_tag 1 #define wippersnapper_analogio_AnalogIOEvent_sensor_event_tag 2 +#define wippersnapper_analogio_AnalogIOD2B_analogio_event_tag 10 /* Struct field encoding specification for nanopb */ +#define wippersnapper_analogio_AnalogIOB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,analogio_add,payload.analogio_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,analogio_remove,payload.analogio_remove), 11) +#define wippersnapper_analogio_AnalogIOB2D_CALLBACK NULL +#define wippersnapper_analogio_AnalogIOB2D_DEFAULT NULL +#define wippersnapper_analogio_AnalogIOB2D_payload_analogio_add_MSGTYPE wippersnapper_analogio_AnalogIOAdd +#define wippersnapper_analogio_AnalogIOB2D_payload_analogio_remove_MSGTYPE wippersnapper_analogio_AnalogIORemove + +#define wippersnapper_analogio_AnalogIOD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,analogio_event,payload.analogio_event), 10) +#define wippersnapper_analogio_AnalogIOD2B_CALLBACK NULL +#define wippersnapper_analogio_AnalogIOD2B_DEFAULT NULL +#define wippersnapper_analogio_AnalogIOD2B_payload_analogio_event_MSGTYPE wippersnapper_analogio_AnalogIOEvent + #define wippersnapper_analogio_AnalogIOAdd_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, pin_name, 1) \ X(a, STATIC, SINGULAR, FLOAT, period, 2) \ @@ -74,20 +114,28 @@ X(a, STATIC, OPTIONAL, MESSAGE, sensor_event, 2) #define wippersnapper_analogio_AnalogIOEvent_DEFAULT NULL #define wippersnapper_analogio_AnalogIOEvent_sensor_event_MSGTYPE wippersnapper_sensor_SensorEvent +extern const pb_msgdesc_t wippersnapper_analogio_AnalogIOB2D_msg; +extern const pb_msgdesc_t wippersnapper_analogio_AnalogIOD2B_msg; extern const pb_msgdesc_t wippersnapper_analogio_AnalogIOAdd_msg; extern const pb_msgdesc_t wippersnapper_analogio_AnalogIORemove_msg; extern const pb_msgdesc_t wippersnapper_analogio_AnalogIOEvent_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_analogio_AnalogIOB2D_fields &wippersnapper_analogio_AnalogIOB2D_msg +#define wippersnapper_analogio_AnalogIOD2B_fields &wippersnapper_analogio_AnalogIOD2B_msg #define wippersnapper_analogio_AnalogIOAdd_fields &wippersnapper_analogio_AnalogIOAdd_msg #define wippersnapper_analogio_AnalogIORemove_fields &wippersnapper_analogio_AnalogIORemove_msg #define wippersnapper_analogio_AnalogIOEvent_fields &wippersnapper_analogio_AnalogIOEvent_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_ANALOGIO_ANALOGIO_PB_H_MAX_SIZE wippersnapper_analogio_AnalogIOAdd_size +#if defined(wippersnapper_sensor_SensorEvent_size) +#endif #define wippersnapper_analogio_AnalogIOAdd_size 72 +#define wippersnapper_analogio_AnalogIOB2D_size 74 #define wippersnapper_analogio_AnalogIORemove_size 65 #if defined(wippersnapper_sensor_SensorEvent_size) +#define WIPPERSNAPPER_ANALOGIO_ANALOGIO_PB_H_MAX_SIZE wippersnapper_analogio_AnalogIOD2B_size +#define wippersnapper_analogio_AnalogIOD2B_size (77 + wippersnapper_sensor_SensorEvent_size) #define wippersnapper_analogio_AnalogIOEvent_size (71 + wippersnapper_sensor_SensorEvent_size) #endif diff --git a/src/protos/checkin.pb.c b/src/protos/checkin.pb.c index 05f7f72d5..26731b2be 100644 --- a/src/protos/checkin.pb.c +++ b/src/protos/checkin.pb.c @@ -6,11 +6,23 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_checkin_CheckinB2D, wippersnapper_checkin_CheckinB2D, AUTO) + + +PB_BIND(wippersnapper_checkin_CheckinD2B, wippersnapper_checkin_CheckinD2B, AUTO) + + PB_BIND(wippersnapper_checkin_CheckinRequest, wippersnapper_checkin_CheckinRequest, AUTO) PB_BIND(wippersnapper_checkin_CheckinResponse, wippersnapper_checkin_CheckinResponse, AUTO) +PB_BIND(wippersnapper_checkin_ComponentAdd, wippersnapper_checkin_ComponentAdd, 2) + + +PB_BIND(wippersnapper_checkin_CheckinComplete, wippersnapper_checkin_CheckinComplete, AUTO) + + diff --git a/src/protos/checkin.pb.h b/src/protos/checkin.pb.h index 63de0007b..5ec7241e9 100644 --- a/src/protos/checkin.pb.h +++ b/src/protos/checkin.pb.h @@ -4,6 +4,14 @@ #ifndef PB_WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_INCLUDED #define PB_WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_INCLUDED #include +#include "analogio.pb.h" +#include "digitalio.pb.h" +#include "ds18x20.pb.h" +#include "i2c.pb.h" +#include "pixels.pb.h" +#include "pwm.pb.h" +#include "servo.pb.h" +#include "uart.pb.h" #if PB_PROTO_HEADER_VERSION != 40 #error Regenerate this file with the current version of nanopb generator. @@ -33,8 +41,51 @@ typedef struct _wippersnapper_checkin_CheckinResponse { int32_t total_gpio_pins; /* * Specifies the number of GPIO pins on the device. */ int32_t total_analog_pins; /* * Specifies the number of analog pins on the device. */ float reference_voltage; /* * Specifies the hardware's default reference voltage. */ + pb_callback_t component_adds; /* * A list of components to set up and initialize during checkin */ } wippersnapper_checkin_CheckinResponse; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_checkin_CheckinB2D { + pb_size_t which_payload; + union { + wippersnapper_checkin_CheckinResponse checkin_response; + } payload; +} wippersnapper_checkin_CheckinB2D; + +/* * + Generic component add message, could contain any *Add message from component protos */ +typedef struct _wippersnapper_checkin_ComponentAdd { + pb_size_t which_payload; + union { + wippersnapper_digitalio_DigitalIOAdd digitalio; + wippersnapper_analogio_AnalogIOAdd analogio; + wippersnapper_servo_ServoAdd servo; + wippersnapper_pwm_PWMAdd pwm; + wippersnapper_pixels_PixelsAdd pixels; + wippersnapper_ds18x20_Ds18x20Add ds18x20; + wippersnapper_uart_UartAdd uart; + wippersnapper_i2c_I2cDeviceAddOrReplace i2c; + } payload; +} wippersnapper_checkin_ComponentAdd; + +/* * + Signal to the broker that the device has completed the checkin + routine and is now operating normally */ +typedef struct _wippersnapper_checkin_CheckinComplete { + char dummy_field; +} wippersnapper_checkin_CheckinComplete; + +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_checkin_CheckinD2B { + pb_size_t which_payload; + union { + wippersnapper_checkin_CheckinRequest checkin_request; + wippersnapper_checkin_CheckinComplete checkin_complete; + } payload; +} wippersnapper_checkin_CheckinD2B; + #ifdef __cplusplus extern "C" { @@ -46,14 +97,26 @@ extern "C" { #define _wippersnapper_checkin_CheckinResponse_Response_ARRAYSIZE ((wippersnapper_checkin_CheckinResponse_Response)(wippersnapper_checkin_CheckinResponse_Response_RESPONSE_BOARD_NOT_FOUND+1)) + + #define wippersnapper_checkin_CheckinResponse_response_ENUMTYPE wippersnapper_checkin_CheckinResponse_Response + + /* Initializer values for message structs */ +#define wippersnapper_checkin_CheckinB2D_init_default {0, {wippersnapper_checkin_CheckinResponse_init_default}} +#define wippersnapper_checkin_CheckinD2B_init_default {0, {wippersnapper_checkin_CheckinRequest_init_default}} #define wippersnapper_checkin_CheckinRequest_init_default {"", ""} -#define wippersnapper_checkin_CheckinResponse_init_default {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0} +#define wippersnapper_checkin_CheckinResponse_init_default {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0, {{NULL}, NULL}} +#define wippersnapper_checkin_ComponentAdd_init_default {0, {wippersnapper_digitalio_DigitalIOAdd_init_default}} +#define wippersnapper_checkin_CheckinComplete_init_default {0} +#define wippersnapper_checkin_CheckinB2D_init_zero {0, {wippersnapper_checkin_CheckinResponse_init_zero}} +#define wippersnapper_checkin_CheckinD2B_init_zero {0, {wippersnapper_checkin_CheckinRequest_init_zero}} #define wippersnapper_checkin_CheckinRequest_init_zero {"", ""} -#define wippersnapper_checkin_CheckinResponse_init_zero {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0} +#define wippersnapper_checkin_CheckinResponse_init_zero {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0, {{NULL}, NULL}} +#define wippersnapper_checkin_ComponentAdd_init_zero {0, {wippersnapper_digitalio_DigitalIOAdd_init_zero}} +#define wippersnapper_checkin_CheckinComplete_init_zero {0} /* Field tags (for use in manual encoding/decoding) */ #define wippersnapper_checkin_CheckinRequest_hardware_uid_tag 1 @@ -62,8 +125,34 @@ extern "C" { #define wippersnapper_checkin_CheckinResponse_total_gpio_pins_tag 2 #define wippersnapper_checkin_CheckinResponse_total_analog_pins_tag 3 #define wippersnapper_checkin_CheckinResponse_reference_voltage_tag 4 +#define wippersnapper_checkin_CheckinResponse_component_adds_tag 5 +#define wippersnapper_checkin_CheckinB2D_checkin_response_tag 10 +#define wippersnapper_checkin_ComponentAdd_digitalio_tag 1 +#define wippersnapper_checkin_ComponentAdd_analogio_tag 2 +#define wippersnapper_checkin_ComponentAdd_servo_tag 3 +#define wippersnapper_checkin_ComponentAdd_pwm_tag 4 +#define wippersnapper_checkin_ComponentAdd_pixels_tag 5 +#define wippersnapper_checkin_ComponentAdd_ds18x20_tag 6 +#define wippersnapper_checkin_ComponentAdd_uart_tag 7 +#define wippersnapper_checkin_ComponentAdd_i2c_tag 8 +#define wippersnapper_checkin_CheckinD2B_checkin_request_tag 1 +#define wippersnapper_checkin_CheckinD2B_checkin_complete_tag 2 /* Struct field encoding specification for nanopb */ +#define wippersnapper_checkin_CheckinB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,checkin_response,payload.checkin_response), 10) +#define wippersnapper_checkin_CheckinB2D_CALLBACK NULL +#define wippersnapper_checkin_CheckinB2D_DEFAULT NULL +#define wippersnapper_checkin_CheckinB2D_payload_checkin_response_MSGTYPE wippersnapper_checkin_CheckinResponse + +#define wippersnapper_checkin_CheckinD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,checkin_request,payload.checkin_request), 1) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,checkin_complete,payload.checkin_complete), 2) +#define wippersnapper_checkin_CheckinD2B_CALLBACK NULL +#define wippersnapper_checkin_CheckinD2B_DEFAULT NULL +#define wippersnapper_checkin_CheckinD2B_payload_checkin_request_MSGTYPE wippersnapper_checkin_CheckinRequest +#define wippersnapper_checkin_CheckinD2B_payload_checkin_complete_MSGTYPE wippersnapper_checkin_CheckinComplete + #define wippersnapper_checkin_CheckinRequest_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, hardware_uid, 1) \ X(a, STATIC, SINGULAR, STRING, firmware_version, 2) @@ -74,21 +163,65 @@ X(a, STATIC, SINGULAR, STRING, firmware_version, 2) X(a, STATIC, SINGULAR, UENUM, response, 1) \ X(a, STATIC, SINGULAR, INT32, total_gpio_pins, 2) \ X(a, STATIC, SINGULAR, INT32, total_analog_pins, 3) \ -X(a, STATIC, SINGULAR, FLOAT, reference_voltage, 4) -#define wippersnapper_checkin_CheckinResponse_CALLBACK NULL +X(a, STATIC, SINGULAR, FLOAT, reference_voltage, 4) \ +X(a, CALLBACK, REPEATED, MESSAGE, component_adds, 5) +#define wippersnapper_checkin_CheckinResponse_CALLBACK pb_default_field_callback #define wippersnapper_checkin_CheckinResponse_DEFAULT NULL - +#define wippersnapper_checkin_CheckinResponse_component_adds_MSGTYPE wippersnapper_checkin_ComponentAdd + +#define wippersnapper_checkin_ComponentAdd_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,digitalio,payload.digitalio), 1) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,analogio,payload.analogio), 2) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,servo,payload.servo), 3) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pwm,payload.pwm), 4) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pixels,payload.pixels), 5) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,ds18x20,payload.ds18x20), 6) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart,payload.uart), 7) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c,payload.i2c), 8) +#define wippersnapper_checkin_ComponentAdd_CALLBACK NULL +#define wippersnapper_checkin_ComponentAdd_DEFAULT NULL +#define wippersnapper_checkin_ComponentAdd_payload_digitalio_MSGTYPE wippersnapper_digitalio_DigitalIOAdd +#define wippersnapper_checkin_ComponentAdd_payload_analogio_MSGTYPE wippersnapper_analogio_AnalogIOAdd +#define wippersnapper_checkin_ComponentAdd_payload_servo_MSGTYPE wippersnapper_servo_ServoAdd +#define wippersnapper_checkin_ComponentAdd_payload_pwm_MSGTYPE wippersnapper_pwm_PWMAdd +#define wippersnapper_checkin_ComponentAdd_payload_pixels_MSGTYPE wippersnapper_pixels_PixelsAdd +#define wippersnapper_checkin_ComponentAdd_payload_ds18x20_MSGTYPE wippersnapper_ds18x20_Ds18x20Add +#define wippersnapper_checkin_ComponentAdd_payload_uart_MSGTYPE wippersnapper_uart_UartAdd +#define wippersnapper_checkin_ComponentAdd_payload_i2c_MSGTYPE wippersnapper_i2c_I2cDeviceAddOrReplace + +#define wippersnapper_checkin_CheckinComplete_FIELDLIST(X, a) \ + +#define wippersnapper_checkin_CheckinComplete_CALLBACK NULL +#define wippersnapper_checkin_CheckinComplete_DEFAULT NULL + +extern const pb_msgdesc_t wippersnapper_checkin_CheckinB2D_msg; +extern const pb_msgdesc_t wippersnapper_checkin_CheckinD2B_msg; extern const pb_msgdesc_t wippersnapper_checkin_CheckinRequest_msg; extern const pb_msgdesc_t wippersnapper_checkin_CheckinResponse_msg; +extern const pb_msgdesc_t wippersnapper_checkin_ComponentAdd_msg; +extern const pb_msgdesc_t wippersnapper_checkin_CheckinComplete_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_checkin_CheckinB2D_fields &wippersnapper_checkin_CheckinB2D_msg +#define wippersnapper_checkin_CheckinD2B_fields &wippersnapper_checkin_CheckinD2B_msg #define wippersnapper_checkin_CheckinRequest_fields &wippersnapper_checkin_CheckinRequest_msg #define wippersnapper_checkin_CheckinResponse_fields &wippersnapper_checkin_CheckinResponse_msg +#define wippersnapper_checkin_ComponentAdd_fields &wippersnapper_checkin_ComponentAdd_msg +#define wippersnapper_checkin_CheckinComplete_fields &wippersnapper_checkin_CheckinComplete_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_MAX_SIZE wippersnapper_checkin_CheckinRequest_size +#if defined(wippersnapper_uart_UartAdd_size) +union wippersnapper_checkin_ComponentAdd_payload_size_union {char f7[(6 + wippersnapper_uart_UartAdd_size)]; char f0[1920];}; +#endif +/* wippersnapper_checkin_CheckinB2D_size depends on runtime parameters */ +/* wippersnapper_checkin_CheckinResponse_size depends on runtime parameters */ +#define WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_MAX_SIZE wippersnapper_checkin_CheckinD2B_size +#define wippersnapper_checkin_CheckinComplete_size 0 +#define wippersnapper_checkin_CheckinD2B_size 93 #define wippersnapper_checkin_CheckinRequest_size 91 -#define wippersnapper_checkin_CheckinResponse_size 29 +#if defined(wippersnapper_uart_UartAdd_size) +#define wippersnapper_checkin_ComponentAdd_size (0 + sizeof(union wippersnapper_checkin_ComponentAdd_payload_size_union)) +#endif #ifdef __cplusplus } /* extern "C" */ diff --git a/src/protos/digitalio.pb.c b/src/protos/digitalio.pb.c index 5467990fd..0961c05b5 100644 --- a/src/protos/digitalio.pb.c +++ b/src/protos/digitalio.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_digitalio_DigitalIOB2D, wippersnapper_digitalio_DigitalIOB2D, AUTO) + + +PB_BIND(wippersnapper_digitalio_DigitalIOD2B, wippersnapper_digitalio_DigitalIOD2B, AUTO) + + PB_BIND(wippersnapper_digitalio_DigitalIOAdd, wippersnapper_digitalio_DigitalIOAdd, AUTO) diff --git a/src/protos/digitalio.pb.h b/src/protos/digitalio.pb.h index 19b98ef49..a8aa4b5f4 100644 --- a/src/protos/digitalio.pb.h +++ b/src/protos/digitalio.pb.h @@ -53,6 +53,15 @@ typedef struct _wippersnapper_digitalio_DigitalIOEvent { wippersnapper_sensor_SensorEvent value; /* * The pin's value. */ } wippersnapper_digitalio_DigitalIOEvent; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_digitalio_DigitalIOD2B { + pb_size_t which_payload; + union { + wippersnapper_digitalio_DigitalIOEvent digitalio_event; + } payload; +} wippersnapper_digitalio_DigitalIOD2B; + /* * DigitalIOWrite writes a boolean value to a digital pin. */ typedef struct _wippersnapper_digitalio_DigitalIOWrite { @@ -61,6 +70,17 @@ typedef struct _wippersnapper_digitalio_DigitalIOWrite { wippersnapper_sensor_SensorEvent value; /* * The pin's value. */ } wippersnapper_digitalio_DigitalIOWrite; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_digitalio_DigitalIOB2D { + pb_size_t which_payload; + union { + wippersnapper_digitalio_DigitalIOAdd digitalio_add; + wippersnapper_digitalio_DigitalIORemove digitalio_remove; + wippersnapper_digitalio_DigitalIOWrite digitalio_write; + } payload; +} wippersnapper_digitalio_DigitalIOB2D; + #ifdef __cplusplus extern "C" { @@ -75,6 +95,8 @@ extern "C" { #define _wippersnapper_digitalio_DigitalIODirection_MAX wippersnapper_digitalio_DigitalIODirection_DIGITAL_IO_DIRECTION_OUTPUT #define _wippersnapper_digitalio_DigitalIODirection_ARRAYSIZE ((wippersnapper_digitalio_DigitalIODirection)(wippersnapper_digitalio_DigitalIODirection_DIGITAL_IO_DIRECTION_OUTPUT+1)) + + #define wippersnapper_digitalio_DigitalIOAdd_gpio_direction_ENUMTYPE wippersnapper_digitalio_DigitalIODirection #define wippersnapper_digitalio_DigitalIOAdd_sample_mode_ENUMTYPE wippersnapper_digitalio_DigitalIOSampleMode @@ -83,10 +105,14 @@ extern "C" { /* Initializer values for message structs */ +#define wippersnapper_digitalio_DigitalIOB2D_init_default {0, {wippersnapper_digitalio_DigitalIOAdd_init_default}} +#define wippersnapper_digitalio_DigitalIOD2B_init_default {0, {wippersnapper_digitalio_DigitalIOEvent_init_default}} #define wippersnapper_digitalio_DigitalIOAdd_init_default {"", _wippersnapper_digitalio_DigitalIODirection_MIN, _wippersnapper_digitalio_DigitalIOSampleMode_MIN, 0, 0} #define wippersnapper_digitalio_DigitalIORemove_init_default {""} #define wippersnapper_digitalio_DigitalIOEvent_init_default {"", false, wippersnapper_sensor_SensorEvent_init_default} #define wippersnapper_digitalio_DigitalIOWrite_init_default {"", false, wippersnapper_sensor_SensorEvent_init_default} +#define wippersnapper_digitalio_DigitalIOB2D_init_zero {0, {wippersnapper_digitalio_DigitalIOAdd_init_zero}} +#define wippersnapper_digitalio_DigitalIOD2B_init_zero {0, {wippersnapper_digitalio_DigitalIOEvent_init_zero}} #define wippersnapper_digitalio_DigitalIOAdd_init_zero {"", _wippersnapper_digitalio_DigitalIODirection_MIN, _wippersnapper_digitalio_DigitalIOSampleMode_MIN, 0, 0} #define wippersnapper_digitalio_DigitalIORemove_init_zero {""} #define wippersnapper_digitalio_DigitalIOEvent_init_zero {"", false, wippersnapper_sensor_SensorEvent_init_zero} @@ -101,10 +127,30 @@ extern "C" { #define wippersnapper_digitalio_DigitalIORemove_pin_name_tag 1 #define wippersnapper_digitalio_DigitalIOEvent_pin_name_tag 1 #define wippersnapper_digitalio_DigitalIOEvent_value_tag 2 +#define wippersnapper_digitalio_DigitalIOD2B_digitalio_event_tag 10 #define wippersnapper_digitalio_DigitalIOWrite_pin_name_tag 1 #define wippersnapper_digitalio_DigitalIOWrite_value_tag 2 +#define wippersnapper_digitalio_DigitalIOB2D_digitalio_add_tag 10 +#define wippersnapper_digitalio_DigitalIOB2D_digitalio_remove_tag 11 +#define wippersnapper_digitalio_DigitalIOB2D_digitalio_write_tag 12 /* Struct field encoding specification for nanopb */ +#define wippersnapper_digitalio_DigitalIOB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,digitalio_add,payload.digitalio_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,digitalio_remove,payload.digitalio_remove), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,digitalio_write,payload.digitalio_write), 12) +#define wippersnapper_digitalio_DigitalIOB2D_CALLBACK NULL +#define wippersnapper_digitalio_DigitalIOB2D_DEFAULT NULL +#define wippersnapper_digitalio_DigitalIOB2D_payload_digitalio_add_MSGTYPE wippersnapper_digitalio_DigitalIOAdd +#define wippersnapper_digitalio_DigitalIOB2D_payload_digitalio_remove_MSGTYPE wippersnapper_digitalio_DigitalIORemove +#define wippersnapper_digitalio_DigitalIOB2D_payload_digitalio_write_MSGTYPE wippersnapper_digitalio_DigitalIOWrite + +#define wippersnapper_digitalio_DigitalIOD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,digitalio_event,payload.digitalio_event), 10) +#define wippersnapper_digitalio_DigitalIOD2B_CALLBACK NULL +#define wippersnapper_digitalio_DigitalIOD2B_DEFAULT NULL +#define wippersnapper_digitalio_DigitalIOD2B_payload_digitalio_event_MSGTYPE wippersnapper_digitalio_DigitalIOEvent + #define wippersnapper_digitalio_DigitalIOAdd_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, pin_name, 1) \ X(a, STATIC, SINGULAR, UENUM, gpio_direction, 2) \ @@ -133,25 +179,36 @@ X(a, STATIC, OPTIONAL, MESSAGE, value, 2) #define wippersnapper_digitalio_DigitalIOWrite_DEFAULT NULL #define wippersnapper_digitalio_DigitalIOWrite_value_MSGTYPE wippersnapper_sensor_SensorEvent +extern const pb_msgdesc_t wippersnapper_digitalio_DigitalIOB2D_msg; +extern const pb_msgdesc_t wippersnapper_digitalio_DigitalIOD2B_msg; extern const pb_msgdesc_t wippersnapper_digitalio_DigitalIOAdd_msg; extern const pb_msgdesc_t wippersnapper_digitalio_DigitalIORemove_msg; extern const pb_msgdesc_t wippersnapper_digitalio_DigitalIOEvent_msg; extern const pb_msgdesc_t wippersnapper_digitalio_DigitalIOWrite_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_digitalio_DigitalIOB2D_fields &wippersnapper_digitalio_DigitalIOB2D_msg +#define wippersnapper_digitalio_DigitalIOD2B_fields &wippersnapper_digitalio_DigitalIOD2B_msg #define wippersnapper_digitalio_DigitalIOAdd_fields &wippersnapper_digitalio_DigitalIOAdd_msg #define wippersnapper_digitalio_DigitalIORemove_fields &wippersnapper_digitalio_DigitalIORemove_msg #define wippersnapper_digitalio_DigitalIOEvent_fields &wippersnapper_digitalio_DigitalIOEvent_msg #define wippersnapper_digitalio_DigitalIOWrite_fields &wippersnapper_digitalio_DigitalIOWrite_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_DIGITALIO_DIGITALIO_PB_H_MAX_SIZE wippersnapper_digitalio_DigitalIOAdd_size -#define wippersnapper_digitalio_DigitalIOAdd_size 76 -#define wippersnapper_digitalio_DigitalIORemove_size 65 #if defined(wippersnapper_sensor_SensorEvent_size) +union wippersnapper_digitalio_DigitalIOB2D_payload_size_union {char f12[(77 + wippersnapper_sensor_SensorEvent_size)]; char f0[78];}; +#endif +#if defined(wippersnapper_sensor_SensorEvent_size) +#endif +#if defined(wippersnapper_sensor_SensorEvent_size) +#define WIPPERSNAPPER_DIGITALIO_DIGITALIO_PB_H_MAX_SIZE wippersnapper_digitalio_DigitalIOD2B_size +#define wippersnapper_digitalio_DigitalIOB2D_size (0 + sizeof(union wippersnapper_digitalio_DigitalIOB2D_payload_size_union)) +#define wippersnapper_digitalio_DigitalIOD2B_size (77 + wippersnapper_sensor_SensorEvent_size) #define wippersnapper_digitalio_DigitalIOEvent_size (71 + wippersnapper_sensor_SensorEvent_size) #define wippersnapper_digitalio_DigitalIOWrite_size (71 + wippersnapper_sensor_SensorEvent_size) #endif +#define wippersnapper_digitalio_DigitalIOAdd_size 76 +#define wippersnapper_digitalio_DigitalIORemove_size 65 #ifdef __cplusplus } /* extern "C" */ diff --git a/src/protos/ds18x20.pb.c b/src/protos/ds18x20.pb.c index e34ce503a..cbd4614db 100644 --- a/src/protos/ds18x20.pb.c +++ b/src/protos/ds18x20.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_ds18x20_Ds18x20B2D, wippersnapper_ds18x20_Ds18x20B2D, AUTO) + + +PB_BIND(wippersnapper_ds18x20_Ds18x20D2B, wippersnapper_ds18x20_Ds18x20D2B, AUTO) + + PB_BIND(wippersnapper_ds18x20_Ds18x20Add, wippersnapper_ds18x20_Ds18x20Add, AUTO) diff --git a/src/protos/ds18x20.pb.h b/src/protos/ds18x20.pb.h index 52040ab6a..b7aa64250 100644 --- a/src/protos/ds18x20.pb.h +++ b/src/protos/ds18x20.pb.h @@ -38,6 +38,16 @@ typedef struct _wippersnapper_ds18x20_Ds18x20Remove { char onewire_pin[5]; /* * The desired onewire bus to de-initialize a DS18x sensor on and release. */ } wippersnapper_ds18x20_Ds18x20Remove; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_ds18x20_Ds18x20B2D { + pb_size_t which_payload; + union { + wippersnapper_ds18x20_Ds18x20Add ds18x20_add; + wippersnapper_ds18x20_Ds18x20Remove ds18x20_remove; + } payload; +} wippersnapper_ds18x20_Ds18x20B2D; + /* * Ds18x20Event event represents data from **one** DS18X20 sensor. */ typedef struct _wippersnapper_ds18x20_Ds18x20Event { @@ -46,16 +56,30 @@ typedef struct _wippersnapper_ds18x20_Ds18x20Event { wippersnapper_sensor_SensorEvent sensor_events[2]; /* * The DS18X20's SensorEvent. */ } wippersnapper_ds18x20_Ds18x20Event; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_ds18x20_Ds18x20D2B { + pb_size_t which_payload; + union { + wippersnapper_ds18x20_Ds18x20Added ds18x20_added; + wippersnapper_ds18x20_Ds18x20Event ds18x20_event; + } payload; +} wippersnapper_ds18x20_Ds18x20D2B; + #ifdef __cplusplus extern "C" { #endif /* Initializer values for message structs */ +#define wippersnapper_ds18x20_Ds18x20B2D_init_default {0, {wippersnapper_ds18x20_Ds18x20Add_init_default}} +#define wippersnapper_ds18x20_Ds18x20D2B_init_default {0, {wippersnapper_ds18x20_Ds18x20Added_init_default}} #define wippersnapper_ds18x20_Ds18x20Add_init_default {"", 0, 0, 0, {_wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN}} #define wippersnapper_ds18x20_Ds18x20Added_init_default {0, ""} #define wippersnapper_ds18x20_Ds18x20Remove_init_default {""} #define wippersnapper_ds18x20_Ds18x20Event_init_default {"", 0, {wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default}} +#define wippersnapper_ds18x20_Ds18x20B2D_init_zero {0, {wippersnapper_ds18x20_Ds18x20Add_init_zero}} +#define wippersnapper_ds18x20_Ds18x20D2B_init_zero {0, {wippersnapper_ds18x20_Ds18x20Added_init_zero}} #define wippersnapper_ds18x20_Ds18x20Add_init_zero {"", 0, 0, 0, {_wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN}} #define wippersnapper_ds18x20_Ds18x20Added_init_zero {0, ""} #define wippersnapper_ds18x20_Ds18x20Remove_init_zero {""} @@ -69,10 +93,30 @@ extern "C" { #define wippersnapper_ds18x20_Ds18x20Added_is_initialized_tag 1 #define wippersnapper_ds18x20_Ds18x20Added_onewire_pin_tag 2 #define wippersnapper_ds18x20_Ds18x20Remove_onewire_pin_tag 1 +#define wippersnapper_ds18x20_Ds18x20B2D_ds18x20_add_tag 10 +#define wippersnapper_ds18x20_Ds18x20B2D_ds18x20_remove_tag 11 #define wippersnapper_ds18x20_Ds18x20Event_onewire_pin_tag 1 #define wippersnapper_ds18x20_Ds18x20Event_sensor_events_tag 2 +#define wippersnapper_ds18x20_Ds18x20D2B_ds18x20_added_tag 10 +#define wippersnapper_ds18x20_Ds18x20D2B_ds18x20_event_tag 11 /* Struct field encoding specification for nanopb */ +#define wippersnapper_ds18x20_Ds18x20B2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,ds18x20_add,payload.ds18x20_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,ds18x20_remove,payload.ds18x20_remove), 11) +#define wippersnapper_ds18x20_Ds18x20B2D_CALLBACK NULL +#define wippersnapper_ds18x20_Ds18x20B2D_DEFAULT NULL +#define wippersnapper_ds18x20_Ds18x20B2D_payload_ds18x20_add_MSGTYPE wippersnapper_ds18x20_Ds18x20Add +#define wippersnapper_ds18x20_Ds18x20B2D_payload_ds18x20_remove_MSGTYPE wippersnapper_ds18x20_Ds18x20Remove + +#define wippersnapper_ds18x20_Ds18x20D2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,ds18x20_added,payload.ds18x20_added), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,ds18x20_event,payload.ds18x20_event), 11) +#define wippersnapper_ds18x20_Ds18x20D2B_CALLBACK NULL +#define wippersnapper_ds18x20_Ds18x20D2B_DEFAULT NULL +#define wippersnapper_ds18x20_Ds18x20D2B_payload_ds18x20_added_MSGTYPE wippersnapper_ds18x20_Ds18x20Added +#define wippersnapper_ds18x20_Ds18x20D2B_payload_ds18x20_event_MSGTYPE wippersnapper_ds18x20_Ds18x20Event + #define wippersnapper_ds18x20_Ds18x20Add_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, onewire_pin, 1) \ X(a, STATIC, SINGULAR, INT32, sensor_resolution, 2) \ @@ -99,23 +143,32 @@ X(a, STATIC, REPEATED, MESSAGE, sensor_events, 2) #define wippersnapper_ds18x20_Ds18x20Event_DEFAULT NULL #define wippersnapper_ds18x20_Ds18x20Event_sensor_events_MSGTYPE wippersnapper_sensor_SensorEvent +extern const pb_msgdesc_t wippersnapper_ds18x20_Ds18x20B2D_msg; +extern const pb_msgdesc_t wippersnapper_ds18x20_Ds18x20D2B_msg; extern const pb_msgdesc_t wippersnapper_ds18x20_Ds18x20Add_msg; extern const pb_msgdesc_t wippersnapper_ds18x20_Ds18x20Added_msg; extern const pb_msgdesc_t wippersnapper_ds18x20_Ds18x20Remove_msg; extern const pb_msgdesc_t wippersnapper_ds18x20_Ds18x20Event_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_ds18x20_Ds18x20B2D_fields &wippersnapper_ds18x20_Ds18x20B2D_msg +#define wippersnapper_ds18x20_Ds18x20D2B_fields &wippersnapper_ds18x20_Ds18x20D2B_msg #define wippersnapper_ds18x20_Ds18x20Add_fields &wippersnapper_ds18x20_Ds18x20Add_msg #define wippersnapper_ds18x20_Ds18x20Added_fields &wippersnapper_ds18x20_Ds18x20Added_msg #define wippersnapper_ds18x20_Ds18x20Remove_fields &wippersnapper_ds18x20_Ds18x20Remove_msg #define wippersnapper_ds18x20_Ds18x20Event_fields &wippersnapper_ds18x20_Ds18x20Event_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_DS18X20_DS18X20_PB_H_MAX_SIZE wippersnapper_ds18x20_Ds18x20Add_size +#if defined(wippersnapper_sensor_SensorEvent_size) +union wippersnapper_ds18x20_Ds18x20D2B_payload_size_union {char f11[(24 + 2*wippersnapper_sensor_SensorEvent_size)]; char f0[10];}; +#endif +#define WIPPERSNAPPER_DS18X20_DS18X20_PB_H_MAX_SIZE wippersnapper_ds18x20_Ds18x20B2D_size #define wippersnapper_ds18x20_Ds18x20Add_size 26 #define wippersnapper_ds18x20_Ds18x20Added_size 8 +#define wippersnapper_ds18x20_Ds18x20B2D_size 28 #define wippersnapper_ds18x20_Ds18x20Remove_size 6 #if defined(wippersnapper_sensor_SensorEvent_size) +#define wippersnapper_ds18x20_Ds18x20D2B_size (0 + sizeof(union wippersnapper_ds18x20_Ds18x20D2B_payload_size_union)) #define wippersnapper_ds18x20_Ds18x20Event_size (18 + 2*wippersnapper_sensor_SensorEvent_size) #endif diff --git a/src/protos/gps.pb.c b/src/protos/gps.pb.c index 2ab34eafe..008198750 100644 --- a/src/protos/gps.pb.c +++ b/src/protos/gps.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_gps_GPSB2D, wippersnapper_gps_GPSB2D, AUTO) + + +PB_BIND(wippersnapper_gps_GPSD2B, wippersnapper_gps_GPSD2B, 2) + + PB_BIND(wippersnapper_gps_GPSConfig, wippersnapper_gps_GPSConfig, 2) diff --git a/src/protos/gps.pb.h b/src/protos/gps.pb.h index 28f54630c..b08f88691 100644 --- a/src/protos/gps.pb.h +++ b/src/protos/gps.pb.h @@ -10,6 +10,14 @@ #endif /* Struct definitions */ +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_gps_GPSB2D { /* oneof payload { + + } */ + char dummy_field; +} wippersnapper_gps_GPSB2D; + typedef PB_BYTES_ARRAY_T(128) wippersnapper_gps_GPSConfig_commands_ubxes_t; /* * GPSConfig represents a message containing configuration data to set up and configure a GPS. @@ -71,17 +79,30 @@ typedef struct _wippersnapper_gps_GPSEvent { wippersnapper_gps_GPGGAResponse gga_responses[10]; /* * List of GGA responses * */ } wippersnapper_gps_GPSEvent; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_gps_GPSD2B { + pb_size_t which_payload; + union { + wippersnapper_gps_GPSEvent gps_event; + } payload; +} wippersnapper_gps_GPSD2B; + #ifdef __cplusplus extern "C" { #endif /* Initializer values for message structs */ +#define wippersnapper_gps_GPSB2D_init_default {0} +#define wippersnapper_gps_GPSD2B_init_default {0, {wippersnapper_gps_GPSEvent_init_default}} #define wippersnapper_gps_GPSConfig_init_default {0, {"", "", "", "", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0} #define wippersnapper_gps_GPSDateTime_init_default {0, 0, 0, 0, 0, 0, 0} #define wippersnapper_gps_GPSRMCResponse_init_default {false, wippersnapper_gps_GPSDateTime_init_default, "", "", "", "", "", "", ""} #define wippersnapper_gps_GPGGAResponse_init_default {false, wippersnapper_gps_GPSDateTime_init_default, "", "", "", "", 0, 0, "", "", ""} #define wippersnapper_gps_GPSEvent_init_default {0, {wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default}, 0, {wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default}} +#define wippersnapper_gps_GPSB2D_init_zero {0} +#define wippersnapper_gps_GPSD2B_init_zero {0, {wippersnapper_gps_GPSEvent_init_zero}} #define wippersnapper_gps_GPSConfig_init_zero {0, {"", "", "", "", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0} #define wippersnapper_gps_GPSDateTime_init_zero {0, 0, 0, 0, 0, 0, 0} #define wippersnapper_gps_GPSRMCResponse_init_zero {false, wippersnapper_gps_GPSDateTime_init_zero, "", "", "", "", "", "", ""} @@ -119,8 +140,20 @@ extern "C" { #define wippersnapper_gps_GPGGAResponse_geoid_height_tag 10 #define wippersnapper_gps_GPSEvent_rmc_responses_tag 1 #define wippersnapper_gps_GPSEvent_gga_responses_tag 2 +#define wippersnapper_gps_GPSD2B_gps_event_tag 10 /* Struct field encoding specification for nanopb */ +#define wippersnapper_gps_GPSB2D_FIELDLIST(X, a) \ + +#define wippersnapper_gps_GPSB2D_CALLBACK NULL +#define wippersnapper_gps_GPSB2D_DEFAULT NULL + +#define wippersnapper_gps_GPSD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,gps_event,payload.gps_event), 10) +#define wippersnapper_gps_GPSD2B_CALLBACK NULL +#define wippersnapper_gps_GPSD2B_DEFAULT NULL +#define wippersnapper_gps_GPSD2B_payload_gps_event_MSGTYPE wippersnapper_gps_GPSEvent + #define wippersnapper_gps_GPSConfig_FIELDLIST(X, a) \ X(a, STATIC, REPEATED, STRING, commands_pmtks, 1) \ X(a, STATIC, REPEATED, BYTES, commands_ubxes, 2) \ @@ -175,6 +208,8 @@ X(a, STATIC, REPEATED, MESSAGE, gga_responses, 2) #define wippersnapper_gps_GPSEvent_rmc_responses_MSGTYPE wippersnapper_gps_GPSRMCResponse #define wippersnapper_gps_GPSEvent_gga_responses_MSGTYPE wippersnapper_gps_GPGGAResponse +extern const pb_msgdesc_t wippersnapper_gps_GPSB2D_msg; +extern const pb_msgdesc_t wippersnapper_gps_GPSD2B_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSConfig_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSDateTime_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSRMCResponse_msg; @@ -182,6 +217,8 @@ extern const pb_msgdesc_t wippersnapper_gps_GPGGAResponse_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSEvent_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_gps_GPSB2D_fields &wippersnapper_gps_GPSB2D_msg +#define wippersnapper_gps_GPSD2B_fields &wippersnapper_gps_GPSD2B_msg #define wippersnapper_gps_GPSConfig_fields &wippersnapper_gps_GPSConfig_msg #define wippersnapper_gps_GPSDateTime_fields &wippersnapper_gps_GPSDateTime_msg #define wippersnapper_gps_GPSRMCResponse_fields &wippersnapper_gps_GPSRMCResponse_msg @@ -189,9 +226,11 @@ extern const pb_msgdesc_t wippersnapper_gps_GPSEvent_msg; #define wippersnapper_gps_GPSEvent_fields &wippersnapper_gps_GPSEvent_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_GPS_GPS_PB_H_MAX_SIZE wippersnapper_gps_GPSEvent_size +#define WIPPERSNAPPER_GPS_GPS_PB_H_MAX_SIZE wippersnapper_gps_GPSD2B_size #define wippersnapper_gps_GPGGAResponse_size 168 +#define wippersnapper_gps_GPSB2D_size 0 #define wippersnapper_gps_GPSConfig_size 1787 +#define wippersnapper_gps_GPSD2B_size 3133 #define wippersnapper_gps_GPSDateTime_size 77 #define wippersnapper_gps_GPSEvent_size 3130 #define wippersnapper_gps_GPSRMCResponse_size 139 diff --git a/src/protos/i2c.pb.c b/src/protos/i2c.pb.c index f3abb4134..7ff2236e9 100644 --- a/src/protos/i2c.pb.c +++ b/src/protos/i2c.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_i2c_I2cB2D, wippersnapper_i2c_I2cB2D, 2) + + +PB_BIND(wippersnapper_i2c_I2cD2B, wippersnapper_i2c_I2cD2B, 4) + + PB_BIND(wippersnapper_i2c_I2cDeviceDescriptor, wippersnapper_i2c_I2cDeviceDescriptor, AUTO) diff --git a/src/protos/i2c.pb.h b/src/protos/i2c.pb.h index 78992ac52..f6e3922f5 100644 --- a/src/protos/i2c.pb.h +++ b/src/protos/i2c.pb.h @@ -128,6 +128,18 @@ typedef struct _wippersnapper_i2c_I2cDeviceEvent { wippersnapper_sensor_SensorEvent i2c_device_events[15]; /* * Required, but optionally repeated, SensorEvent from a sensor. */ } wippersnapper_i2c_I2cDeviceEvent; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_i2c_I2cD2B { + pb_size_t which_payload; + union { + wippersnapper_i2c_I2cBusScanned i2c_bus_scanned; + wippersnapper_i2c_I2cDeviceAddedOrReplaced i2c_device_added_replaced; + wippersnapper_i2c_I2cDeviceRemoved i2c_device_removed; + wippersnapper_i2c_I2cDeviceEvent i2c_device_event; + } payload; +} wippersnapper_i2c_I2cD2B; + /* * I2cDeviceOutputWrite represents a request to write to an I2C output device. */ typedef struct _wippersnapper_i2c_I2cDeviceOutputWrite { @@ -141,6 +153,18 @@ typedef struct _wippersnapper_i2c_I2cDeviceOutputWrite { } output_msg; } wippersnapper_i2c_I2cDeviceOutputWrite; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_i2c_I2cB2D { + pb_size_t which_payload; + union { + wippersnapper_i2c_I2cBusScan i2c_bus_scan; + wippersnapper_i2c_I2cDeviceAddOrReplace i2c_device_add_replace; + wippersnapper_i2c_I2cDeviceRemove i2c_device_remove; + wippersnapper_i2c_I2cDeviceOutputWrite i2c_device_output_write; + } payload; +} wippersnapper_i2c_I2cB2D; + #ifdef __cplusplus extern "C" { @@ -158,6 +182,8 @@ extern "C" { + + #define wippersnapper_i2c_I2cBusScanned_i2c_bus_status_ENUMTYPE wippersnapper_i2c_I2cBusStatus #define wippersnapper_i2c_I2cDeviceAddOrReplace_i2c_device_sensor_types_ENUMTYPE wippersnapper_sensor_SensorType @@ -171,6 +197,8 @@ extern "C" { /* Initializer values for message structs */ +#define wippersnapper_i2c_I2cB2D_init_default {0, {wippersnapper_i2c_I2cBusScan_init_default}} +#define wippersnapper_i2c_I2cD2B_init_default {0, {wippersnapper_i2c_I2cBusScanned_init_default}} #define wippersnapper_i2c_I2cDeviceDescriptor_init_default {"", "", 0, 0, 0} #define wippersnapper_i2c_I2cBusDescriptor_init_default {"", ""} #define wippersnapper_i2c_I2cBusScan_init_default {0, 0, false, wippersnapper_i2c_I2cBusDescriptor_init_default, 0, 0} @@ -181,6 +209,8 @@ extern "C" { #define wippersnapper_i2c_I2cDeviceRemoved_init_default {false, wippersnapper_i2c_I2cDeviceDescriptor_init_default, 0} #define wippersnapper_i2c_I2cDeviceEvent_init_default {false, wippersnapper_i2c_I2cDeviceDescriptor_init_default, 0, {wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default}} #define wippersnapper_i2c_I2cDeviceOutputWrite_init_default {false, wippersnapper_i2c_I2cDeviceDescriptor_init_default, 0, {wippersnapper_i2c_output_LedBackpackWrite_init_default}} +#define wippersnapper_i2c_I2cB2D_init_zero {0, {wippersnapper_i2c_I2cBusScan_init_zero}} +#define wippersnapper_i2c_I2cD2B_init_zero {0, {wippersnapper_i2c_I2cBusScanned_init_zero}} #define wippersnapper_i2c_I2cDeviceDescriptor_init_zero {"", "", 0, 0, 0} #define wippersnapper_i2c_I2cBusDescriptor_init_zero {"", ""} #define wippersnapper_i2c_I2cBusScan_init_zero {0, 0, false, wippersnapper_i2c_I2cBusDescriptor_init_zero, 0, 0} @@ -225,12 +255,44 @@ extern "C" { #define wippersnapper_i2c_I2cDeviceRemoved_did_remove_tag 2 #define wippersnapper_i2c_I2cDeviceEvent_i2c_device_description_tag 1 #define wippersnapper_i2c_I2cDeviceEvent_i2c_device_events_tag 2 +#define wippersnapper_i2c_I2cD2B_i2c_bus_scanned_tag 10 +#define wippersnapper_i2c_I2cD2B_i2c_device_added_replaced_tag 11 +#define wippersnapper_i2c_I2cD2B_i2c_device_removed_tag 12 +#define wippersnapper_i2c_I2cD2B_i2c_device_event_tag 13 #define wippersnapper_i2c_I2cDeviceOutputWrite_i2c_device_description_tag 1 #define wippersnapper_i2c_I2cDeviceOutputWrite_write_led_backpack_tag 2 #define wippersnapper_i2c_I2cDeviceOutputWrite_write_char_lcd_tag 3 #define wippersnapper_i2c_I2cDeviceOutputWrite_write_oled_tag 4 +#define wippersnapper_i2c_I2cB2D_i2c_bus_scan_tag 10 +#define wippersnapper_i2c_I2cB2D_i2c_device_add_replace_tag 11 +#define wippersnapper_i2c_I2cB2D_i2c_device_remove_tag 12 +#define wippersnapper_i2c_I2cB2D_i2c_device_output_write_tag 13 /* Struct field encoding specification for nanopb */ +#define wippersnapper_i2c_I2cB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_bus_scan,payload.i2c_bus_scan), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_device_add_replace,payload.i2c_device_add_replace), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_device_remove,payload.i2c_device_remove), 12) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_device_output_write,payload.i2c_device_output_write), 13) +#define wippersnapper_i2c_I2cB2D_CALLBACK NULL +#define wippersnapper_i2c_I2cB2D_DEFAULT NULL +#define wippersnapper_i2c_I2cB2D_payload_i2c_bus_scan_MSGTYPE wippersnapper_i2c_I2cBusScan +#define wippersnapper_i2c_I2cB2D_payload_i2c_device_add_replace_MSGTYPE wippersnapper_i2c_I2cDeviceAddOrReplace +#define wippersnapper_i2c_I2cB2D_payload_i2c_device_remove_MSGTYPE wippersnapper_i2c_I2cDeviceRemove +#define wippersnapper_i2c_I2cB2D_payload_i2c_device_output_write_MSGTYPE wippersnapper_i2c_I2cDeviceOutputWrite + +#define wippersnapper_i2c_I2cD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_bus_scanned,payload.i2c_bus_scanned), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_device_added_replaced,payload.i2c_device_added_replaced), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_device_removed,payload.i2c_device_removed), 12) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,i2c_device_event,payload.i2c_device_event), 13) +#define wippersnapper_i2c_I2cD2B_CALLBACK NULL +#define wippersnapper_i2c_I2cD2B_DEFAULT NULL +#define wippersnapper_i2c_I2cD2B_payload_i2c_bus_scanned_MSGTYPE wippersnapper_i2c_I2cBusScanned +#define wippersnapper_i2c_I2cD2B_payload_i2c_device_added_replaced_MSGTYPE wippersnapper_i2c_I2cDeviceAddedOrReplaced +#define wippersnapper_i2c_I2cD2B_payload_i2c_device_removed_MSGTYPE wippersnapper_i2c_I2cDeviceRemoved +#define wippersnapper_i2c_I2cD2B_payload_i2c_device_event_MSGTYPE wippersnapper_i2c_I2cDeviceEvent + #define wippersnapper_i2c_I2cDeviceDescriptor_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, i2c_bus_sda, 1) \ X(a, STATIC, SINGULAR, STRING, i2c_bus_scl, 2) \ @@ -321,6 +383,8 @@ X(a, STATIC, ONEOF, MESSAGE, (output_msg,write_oled,output_msg.write_oled) #define wippersnapper_i2c_I2cDeviceOutputWrite_output_msg_write_char_lcd_MSGTYPE wippersnapper_i2c_output_CharLCDWrite #define wippersnapper_i2c_I2cDeviceOutputWrite_output_msg_write_oled_MSGTYPE wippersnapper_i2c_output_OLEDWrite +extern const pb_msgdesc_t wippersnapper_i2c_I2cB2D_msg; +extern const pb_msgdesc_t wippersnapper_i2c_I2cD2B_msg; extern const pb_msgdesc_t wippersnapper_i2c_I2cDeviceDescriptor_msg; extern const pb_msgdesc_t wippersnapper_i2c_I2cBusDescriptor_msg; extern const pb_msgdesc_t wippersnapper_i2c_I2cBusScan_msg; @@ -333,6 +397,8 @@ extern const pb_msgdesc_t wippersnapper_i2c_I2cDeviceEvent_msg; extern const pb_msgdesc_t wippersnapper_i2c_I2cDeviceOutputWrite_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_i2c_I2cB2D_fields &wippersnapper_i2c_I2cB2D_msg +#define wippersnapper_i2c_I2cD2B_fields &wippersnapper_i2c_I2cD2B_msg #define wippersnapper_i2c_I2cDeviceDescriptor_fields &wippersnapper_i2c_I2cDeviceDescriptor_msg #define wippersnapper_i2c_I2cBusDescriptor_fields &wippersnapper_i2c_I2cBusDescriptor_msg #define wippersnapper_i2c_I2cBusScan_fields &wippersnapper_i2c_I2cBusScan_msg @@ -345,7 +411,11 @@ extern const pb_msgdesc_t wippersnapper_i2c_I2cDeviceOutputWrite_msg; #define wippersnapper_i2c_I2cDeviceOutputWrite_fields &wippersnapper_i2c_I2cDeviceOutputWrite_msg /* Maximum encoded size of messages (where known) */ +#if defined(wippersnapper_sensor_SensorEvent_size) +union wippersnapper_i2c_I2cD2B_payload_size_union {char f13[(148 + 15*wippersnapper_sensor_SensorEvent_size)]; char f0[6245];}; +#endif #define WIPPERSNAPPER_I2C_I2C_PB_H_MAX_SIZE wippersnapper_i2c_I2cBusScanned_size +#define wippersnapper_i2c_I2cB2D_size 1920 #define wippersnapper_i2c_I2cBusDescriptor_size 32 #define wippersnapper_i2c_I2cBusScan_size 42 #define wippersnapper_i2c_I2cBusScanned_size 6242 @@ -356,6 +426,7 @@ extern const pb_msgdesc_t wippersnapper_i2c_I2cDeviceOutputWrite_msg; #define wippersnapper_i2c_I2cDeviceRemove_size 54 #define wippersnapper_i2c_I2cDeviceRemoved_size 54 #if defined(wippersnapper_sensor_SensorEvent_size) +#define wippersnapper_i2c_I2cD2B_size (0 + sizeof(union wippersnapper_i2c_I2cD2B_payload_size_union)) #define wippersnapper_i2c_I2cDeviceEvent_size (142 + 15*wippersnapper_sensor_SensorEvent_size) #endif diff --git a/src/protos/pixels.pb.c b/src/protos/pixels.pb.c index 21a6eed14..1ff34b792 100644 --- a/src/protos/pixels.pb.c +++ b/src/protos/pixels.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_pixels_PixelsB2D, wippersnapper_pixels_PixelsB2D, AUTO) + + +PB_BIND(wippersnapper_pixels_PixelsD2B, wippersnapper_pixels_PixelsD2B, AUTO) + + PB_BIND(wippersnapper_pixels_PixelsAdd, wippersnapper_pixels_PixelsAdd, AUTO) diff --git a/src/protos/pixels.pb.h b/src/protos/pixels.pb.h index b2b1c23b5..cc110d9b0 100644 --- a/src/protos/pixels.pb.h +++ b/src/protos/pixels.pb.h @@ -54,6 +54,15 @@ typedef struct _wippersnapper_pixels_PixelsAdded { char pixels_pin_data[6]; /* * Data pin the responding strand is connected to. */ } wippersnapper_pixels_PixelsAdded; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_pixels_PixelsD2B { + pb_size_t which_payload; + union { + wippersnapper_pixels_PixelsAdded pixels_added; + } payload; +} wippersnapper_pixels_PixelsD2B; + /* * PixelAdd represents a call from IO to a device Removes a strand of addressable pixels and release the resources and pin. */ @@ -70,6 +79,17 @@ typedef struct _wippersnapper_pixels_PixelsWrite { next is red, then green, and least significant byte is blue. */ } wippersnapper_pixels_PixelsWrite; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_pixels_PixelsB2D { + pb_size_t which_payload; + union { + wippersnapper_pixels_PixelsAdd pixels_add; + wippersnapper_pixels_PixelsRemove pixels_remove; + wippersnapper_pixels_PixelsWrite pixels_write; + } payload; +} wippersnapper_pixels_PixelsB2D; + #ifdef __cplusplus extern "C" { @@ -84,6 +104,8 @@ extern "C" { #define _wippersnapper_pixels_PixelsOrder_MAX wippersnapper_pixels_PixelsOrder_PIXELS_ORDER_BGR #define _wippersnapper_pixels_PixelsOrder_ARRAYSIZE ((wippersnapper_pixels_PixelsOrder)(wippersnapper_pixels_PixelsOrder_PIXELS_ORDER_BGR+1)) + + #define wippersnapper_pixels_PixelsAdd_pixels_type_ENUMTYPE wippersnapper_pixels_PixelsType #define wippersnapper_pixels_PixelsAdd_pixels_ordering_ENUMTYPE wippersnapper_pixels_PixelsOrder @@ -92,10 +114,14 @@ extern "C" { /* Initializer values for message structs */ +#define wippersnapper_pixels_PixelsB2D_init_default {0, {wippersnapper_pixels_PixelsAdd_init_default}} +#define wippersnapper_pixels_PixelsD2B_init_default {0, {wippersnapper_pixels_PixelsAdded_init_default}} #define wippersnapper_pixels_PixelsAdd_init_default {_wippersnapper_pixels_PixelsType_MIN, 0, _wippersnapper_pixels_PixelsOrder_MIN, 0, "", ""} #define wippersnapper_pixels_PixelsAdded_init_default {0, ""} #define wippersnapper_pixels_PixelsRemove_init_default {""} #define wippersnapper_pixels_PixelsWrite_init_default {"", 0} +#define wippersnapper_pixels_PixelsB2D_init_zero {0, {wippersnapper_pixels_PixelsAdd_init_zero}} +#define wippersnapper_pixels_PixelsD2B_init_zero {0, {wippersnapper_pixels_PixelsAdded_init_zero}} #define wippersnapper_pixels_PixelsAdd_init_zero {_wippersnapper_pixels_PixelsType_MIN, 0, _wippersnapper_pixels_PixelsOrder_MIN, 0, "", ""} #define wippersnapper_pixels_PixelsAdded_init_zero {0, ""} #define wippersnapper_pixels_PixelsRemove_init_zero {""} @@ -110,11 +136,31 @@ extern "C" { #define wippersnapper_pixels_PixelsAdd_pixels_pin_dotstar_clock_tag 6 #define wippersnapper_pixels_PixelsAdded_is_success_tag 1 #define wippersnapper_pixels_PixelsAdded_pixels_pin_data_tag 2 +#define wippersnapper_pixels_PixelsD2B_pixels_added_tag 10 #define wippersnapper_pixels_PixelsRemove_pixels_pin_data_tag 1 #define wippersnapper_pixels_PixelsWrite_pixels_pin_data_tag 1 #define wippersnapper_pixels_PixelsWrite_pixels_color_tag 2 +#define wippersnapper_pixels_PixelsB2D_pixels_add_tag 10 +#define wippersnapper_pixels_PixelsB2D_pixels_remove_tag 11 +#define wippersnapper_pixels_PixelsB2D_pixels_write_tag 12 /* Struct field encoding specification for nanopb */ +#define wippersnapper_pixels_PixelsB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pixels_add,payload.pixels_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pixels_remove,payload.pixels_remove), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pixels_write,payload.pixels_write), 12) +#define wippersnapper_pixels_PixelsB2D_CALLBACK NULL +#define wippersnapper_pixels_PixelsB2D_DEFAULT NULL +#define wippersnapper_pixels_PixelsB2D_payload_pixels_add_MSGTYPE wippersnapper_pixels_PixelsAdd +#define wippersnapper_pixels_PixelsB2D_payload_pixels_remove_MSGTYPE wippersnapper_pixels_PixelsRemove +#define wippersnapper_pixels_PixelsB2D_payload_pixels_write_MSGTYPE wippersnapper_pixels_PixelsWrite + +#define wippersnapper_pixels_PixelsD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pixels_added,payload.pixels_added), 10) +#define wippersnapper_pixels_PixelsD2B_CALLBACK NULL +#define wippersnapper_pixels_PixelsD2B_DEFAULT NULL +#define wippersnapper_pixels_PixelsD2B_payload_pixels_added_MSGTYPE wippersnapper_pixels_PixelsAdded + #define wippersnapper_pixels_PixelsAdd_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, UENUM, pixels_type, 1) \ X(a, STATIC, SINGULAR, UINT32, pixels_num, 2) \ @@ -142,21 +188,27 @@ X(a, STATIC, SINGULAR, UINT32, pixels_color, 2) #define wippersnapper_pixels_PixelsWrite_CALLBACK NULL #define wippersnapper_pixels_PixelsWrite_DEFAULT NULL +extern const pb_msgdesc_t wippersnapper_pixels_PixelsB2D_msg; +extern const pb_msgdesc_t wippersnapper_pixels_PixelsD2B_msg; extern const pb_msgdesc_t wippersnapper_pixels_PixelsAdd_msg; extern const pb_msgdesc_t wippersnapper_pixels_PixelsAdded_msg; extern const pb_msgdesc_t wippersnapper_pixels_PixelsRemove_msg; extern const pb_msgdesc_t wippersnapper_pixels_PixelsWrite_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_pixels_PixelsB2D_fields &wippersnapper_pixels_PixelsB2D_msg +#define wippersnapper_pixels_PixelsD2B_fields &wippersnapper_pixels_PixelsD2B_msg #define wippersnapper_pixels_PixelsAdd_fields &wippersnapper_pixels_PixelsAdd_msg #define wippersnapper_pixels_PixelsAdded_fields &wippersnapper_pixels_PixelsAdded_msg #define wippersnapper_pixels_PixelsRemove_fields &wippersnapper_pixels_PixelsRemove_msg #define wippersnapper_pixels_PixelsWrite_fields &wippersnapper_pixels_PixelsWrite_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_PIXELS_PIXELS_PB_H_MAX_SIZE wippersnapper_pixels_PixelsAdd_size +#define WIPPERSNAPPER_PIXELS_PIXELS_PB_H_MAX_SIZE wippersnapper_pixels_PixelsB2D_size #define wippersnapper_pixels_PixelsAdd_size 30 #define wippersnapper_pixels_PixelsAdded_size 9 +#define wippersnapper_pixels_PixelsB2D_size 32 +#define wippersnapper_pixels_PixelsD2B_size 11 #define wippersnapper_pixels_PixelsRemove_size 7 #define wippersnapper_pixels_PixelsWrite_size 13 diff --git a/src/protos/pwm.pb.c b/src/protos/pwm.pb.c index 9d52e1045..65f3e3b8f 100644 --- a/src/protos/pwm.pb.c +++ b/src/protos/pwm.pb.c @@ -6,22 +6,22 @@ #error Regenerate this file with the current version of nanopb generator. #endif -PB_BIND(wippersnapper_pwm_PWMAdd, wippersnapper_pwm_PWMAdd, AUTO) +PB_BIND(wippersnapper_pwm_PWMB2D, wippersnapper_pwm_PWMB2D, AUTO) -PB_BIND(wippersnapper_pwm_PWMAdded, wippersnapper_pwm_PWMAdded, AUTO) +PB_BIND(wippersnapper_pwm_PWMD2B, wippersnapper_pwm_PWMD2B, AUTO) -PB_BIND(wippersnapper_pwm_PWMRemove, wippersnapper_pwm_PWMRemove, AUTO) +PB_BIND(wippersnapper_pwm_PWMAdd, wippersnapper_pwm_PWMAdd, AUTO) -PB_BIND(wippersnapper_pwm_PWMWriteDutyCycle, wippersnapper_pwm_PWMWriteDutyCycle, AUTO) +PB_BIND(wippersnapper_pwm_PWMAdded, wippersnapper_pwm_PWMAdded, AUTO) -PB_BIND(wippersnapper_pwm_PWMWriteDutyCycleMulti, wippersnapper_pwm_PWMWriteDutyCycleMulti, AUTO) +PB_BIND(wippersnapper_pwm_PWMRemove, wippersnapper_pwm_PWMRemove, AUTO) -PB_BIND(wippersnapper_pwm_PWMWriteFrequency, wippersnapper_pwm_PWMWriteFrequency, AUTO) +PB_BIND(wippersnapper_pwm_PWMWrite, wippersnapper_pwm_PWMWrite, AUTO) diff --git a/src/protos/pwm.pb.h b/src/protos/pwm.pb.h index 0f3083a2d..0ed1a8daa 100644 --- a/src/protos/pwm.pb.h +++ b/src/protos/pwm.pb.h @@ -28,6 +28,15 @@ typedef struct _wippersnapper_pwm_PWMAdded { bool did_attach; /* * True if Add successful, False otherwise. */ } wippersnapper_pwm_PWMAdded; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_pwm_PWMD2B { + pb_size_t which_payload; + union { + wippersnapper_pwm_PWMAdded pwm_added; + } payload; +} wippersnapper_pwm_PWMD2B; + /* * PWMRemove represents a to stop PWM'ing and release the pin for re-use. On ESP32, this will "detach" a pin from a LEDC channel/timer group. @@ -37,29 +46,29 @@ typedef struct _wippersnapper_pwm_PWMRemove { } wippersnapper_pwm_PWMRemove; /* * - PWMWriteDutyCycle represents a to write a duty cycle to a pin with a frequency (fixed). - This is used for controlling LEDs. */ -typedef struct _wippersnapper_pwm_PWMWriteDutyCycle { + PWMWrite represents writing to a pin either: + - a duty cycle (frequency is fixed) This is used for controlling LEDs. + - a frequency in Hz (duty cycle fixed at 50%) This is used for playing tones using a piezo buzzer or speaker + This value will be changed by the slider on Adafruit IO. */ +typedef struct _wippersnapper_pwm_PWMWrite { char pin[6]; /* * The pin to write to. */ - int32_t duty_cycle; /* * The desired duty cycle to write (range is from 0 to (2 ** duty_resolution)). -This value will be changed by the slider on Adafruit IO. * */ -} wippersnapper_pwm_PWMWriteDutyCycle; + pb_size_t which_payload; + union { + int32_t duty_cycle; /* * The desired duty cycle (range is from 0 to (2 ** duty_resolution)). * */ + int32_t frequency; /* * The desired PWM frequency, in Hz. * */ + } payload; +} wippersnapper_pwm_PWMWrite; /* * - PWMWriteDutyCycleMulti represents a wrapper to write duty cycles to multiple pins. - This is used for controlling RGB/RGBW LEDs. */ -typedef struct _wippersnapper_pwm_PWMWriteDutyCycleMulti { - pb_size_t write_duty_cycle_reqs_count; - wippersnapper_pwm_PWMWriteDutyCycle write_duty_cycle_reqs[4]; /* * Multiple duty cycles to write, one per pin of a RGB LED. * */ -} wippersnapper_pwm_PWMWriteDutyCycleMulti; - -/* * - PWMWriteFrequency represents a to write a Frequency, in Hz, to a pin with a duty cycle of 50%. - This is used for playing tones using a piezo buzzer or speaker. */ -typedef struct _wippersnapper_pwm_PWMWriteFrequency { - char pin[6]; /* * The pin to write to. */ - int32_t frequency; /* * The desired PWM frequency, in Hz. This value will be changed by the slider on Adafruit IO. * */ -} wippersnapper_pwm_PWMWriteFrequency; + BrokerToDevice message envelope */ +typedef struct _wippersnapper_pwm_PWMB2D { + pb_size_t which_payload; + union { + wippersnapper_pwm_PWMAdd pwm_add; + wippersnapper_pwm_PWMRemove pwm_remove; + wippersnapper_pwm_PWMWrite pwm_write; + } payload; +} wippersnapper_pwm_PWMB2D; #ifdef __cplusplus @@ -67,18 +76,18 @@ extern "C" { #endif /* Initializer values for message structs */ +#define wippersnapper_pwm_PWMB2D_init_default {0, {wippersnapper_pwm_PWMAdd_init_default}} +#define wippersnapper_pwm_PWMD2B_init_default {0, {wippersnapper_pwm_PWMAdded_init_default}} #define wippersnapper_pwm_PWMAdd_init_default {"", 0, 0} #define wippersnapper_pwm_PWMAdded_init_default {"", 0} #define wippersnapper_pwm_PWMRemove_init_default {""} -#define wippersnapper_pwm_PWMWriteDutyCycle_init_default {"", 0} -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_init_default {0, {wippersnapper_pwm_PWMWriteDutyCycle_init_default, wippersnapper_pwm_PWMWriteDutyCycle_init_default, wippersnapper_pwm_PWMWriteDutyCycle_init_default, wippersnapper_pwm_PWMWriteDutyCycle_init_default}} -#define wippersnapper_pwm_PWMWriteFrequency_init_default {"", 0} +#define wippersnapper_pwm_PWMWrite_init_default {"", 0, {0}} +#define wippersnapper_pwm_PWMB2D_init_zero {0, {wippersnapper_pwm_PWMAdd_init_zero}} +#define wippersnapper_pwm_PWMD2B_init_zero {0, {wippersnapper_pwm_PWMAdded_init_zero}} #define wippersnapper_pwm_PWMAdd_init_zero {"", 0, 0} #define wippersnapper_pwm_PWMAdded_init_zero {"", 0} #define wippersnapper_pwm_PWMRemove_init_zero {""} -#define wippersnapper_pwm_PWMWriteDutyCycle_init_zero {"", 0} -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_init_zero {0, {wippersnapper_pwm_PWMWriteDutyCycle_init_zero, wippersnapper_pwm_PWMWriteDutyCycle_init_zero, wippersnapper_pwm_PWMWriteDutyCycle_init_zero, wippersnapper_pwm_PWMWriteDutyCycle_init_zero}} -#define wippersnapper_pwm_PWMWriteFrequency_init_zero {"", 0} +#define wippersnapper_pwm_PWMWrite_init_zero {"", 0, {0}} /* Field tags (for use in manual encoding/decoding) */ #define wippersnapper_pwm_PWMAdd_pin_tag 1 @@ -86,14 +95,32 @@ extern "C" { #define wippersnapper_pwm_PWMAdd_resolution_tag 3 #define wippersnapper_pwm_PWMAdded_pin_tag 1 #define wippersnapper_pwm_PWMAdded_did_attach_tag 2 +#define wippersnapper_pwm_PWMD2B_pwm_added_tag 10 #define wippersnapper_pwm_PWMRemove_pin_tag 1 -#define wippersnapper_pwm_PWMWriteDutyCycle_pin_tag 1 -#define wippersnapper_pwm_PWMWriteDutyCycle_duty_cycle_tag 2 -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_write_duty_cycle_reqs_tag 1 -#define wippersnapper_pwm_PWMWriteFrequency_pin_tag 1 -#define wippersnapper_pwm_PWMWriteFrequency_frequency_tag 2 +#define wippersnapper_pwm_PWMWrite_pin_tag 1 +#define wippersnapper_pwm_PWMWrite_duty_cycle_tag 2 +#define wippersnapper_pwm_PWMWrite_frequency_tag 3 +#define wippersnapper_pwm_PWMB2D_pwm_add_tag 10 +#define wippersnapper_pwm_PWMB2D_pwm_remove_tag 11 +#define wippersnapper_pwm_PWMB2D_pwm_write_tag 12 /* Struct field encoding specification for nanopb */ +#define wippersnapper_pwm_PWMB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pwm_add,payload.pwm_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pwm_remove,payload.pwm_remove), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pwm_write,payload.pwm_write), 12) +#define wippersnapper_pwm_PWMB2D_CALLBACK NULL +#define wippersnapper_pwm_PWMB2D_DEFAULT NULL +#define wippersnapper_pwm_PWMB2D_payload_pwm_add_MSGTYPE wippersnapper_pwm_PWMAdd +#define wippersnapper_pwm_PWMB2D_payload_pwm_remove_MSGTYPE wippersnapper_pwm_PWMRemove +#define wippersnapper_pwm_PWMB2D_payload_pwm_write_MSGTYPE wippersnapper_pwm_PWMWrite + +#define wippersnapper_pwm_PWMD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,pwm_added,payload.pwm_added), 10) +#define wippersnapper_pwm_PWMD2B_CALLBACK NULL +#define wippersnapper_pwm_PWMD2B_DEFAULT NULL +#define wippersnapper_pwm_PWMD2B_payload_pwm_added_MSGTYPE wippersnapper_pwm_PWMAdded + #define wippersnapper_pwm_PWMAdd_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, pin, 1) \ X(a, STATIC, SINGULAR, INT32, frequency, 2) \ @@ -112,47 +139,36 @@ X(a, STATIC, SINGULAR, STRING, pin, 1) #define wippersnapper_pwm_PWMRemove_CALLBACK NULL #define wippersnapper_pwm_PWMRemove_DEFAULT NULL -#define wippersnapper_pwm_PWMWriteDutyCycle_FIELDLIST(X, a) \ -X(a, STATIC, SINGULAR, STRING, pin, 1) \ -X(a, STATIC, SINGULAR, INT32, duty_cycle, 2) -#define wippersnapper_pwm_PWMWriteDutyCycle_CALLBACK NULL -#define wippersnapper_pwm_PWMWriteDutyCycle_DEFAULT NULL - -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_FIELDLIST(X, a) \ -X(a, STATIC, REPEATED, MESSAGE, write_duty_cycle_reqs, 1) -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_CALLBACK NULL -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_DEFAULT NULL -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_write_duty_cycle_reqs_MSGTYPE wippersnapper_pwm_PWMWriteDutyCycle - -#define wippersnapper_pwm_PWMWriteFrequency_FIELDLIST(X, a) \ +#define wippersnapper_pwm_PWMWrite_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, pin, 1) \ -X(a, STATIC, SINGULAR, INT32, frequency, 2) -#define wippersnapper_pwm_PWMWriteFrequency_CALLBACK NULL -#define wippersnapper_pwm_PWMWriteFrequency_DEFAULT NULL +X(a, STATIC, ONEOF, INT32, (payload,duty_cycle,payload.duty_cycle), 2) \ +X(a, STATIC, ONEOF, INT32, (payload,frequency,payload.frequency), 3) +#define wippersnapper_pwm_PWMWrite_CALLBACK NULL +#define wippersnapper_pwm_PWMWrite_DEFAULT NULL +extern const pb_msgdesc_t wippersnapper_pwm_PWMB2D_msg; +extern const pb_msgdesc_t wippersnapper_pwm_PWMD2B_msg; extern const pb_msgdesc_t wippersnapper_pwm_PWMAdd_msg; extern const pb_msgdesc_t wippersnapper_pwm_PWMAdded_msg; extern const pb_msgdesc_t wippersnapper_pwm_PWMRemove_msg; -extern const pb_msgdesc_t wippersnapper_pwm_PWMWriteDutyCycle_msg; -extern const pb_msgdesc_t wippersnapper_pwm_PWMWriteDutyCycleMulti_msg; -extern const pb_msgdesc_t wippersnapper_pwm_PWMWriteFrequency_msg; +extern const pb_msgdesc_t wippersnapper_pwm_PWMWrite_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_pwm_PWMB2D_fields &wippersnapper_pwm_PWMB2D_msg +#define wippersnapper_pwm_PWMD2B_fields &wippersnapper_pwm_PWMD2B_msg #define wippersnapper_pwm_PWMAdd_fields &wippersnapper_pwm_PWMAdd_msg #define wippersnapper_pwm_PWMAdded_fields &wippersnapper_pwm_PWMAdded_msg #define wippersnapper_pwm_PWMRemove_fields &wippersnapper_pwm_PWMRemove_msg -#define wippersnapper_pwm_PWMWriteDutyCycle_fields &wippersnapper_pwm_PWMWriteDutyCycle_msg -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_fields &wippersnapper_pwm_PWMWriteDutyCycleMulti_msg -#define wippersnapper_pwm_PWMWriteFrequency_fields &wippersnapper_pwm_PWMWriteFrequency_msg +#define wippersnapper_pwm_PWMWrite_fields &wippersnapper_pwm_PWMWrite_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_PWM_PWM_PB_H_MAX_SIZE wippersnapper_pwm_PWMWriteDutyCycleMulti_size +#define WIPPERSNAPPER_PWM_PWM_PB_H_MAX_SIZE wippersnapper_pwm_PWMB2D_size #define wippersnapper_pwm_PWMAdd_size 29 #define wippersnapper_pwm_PWMAdded_size 9 +#define wippersnapper_pwm_PWMB2D_size 31 +#define wippersnapper_pwm_PWMD2B_size 11 #define wippersnapper_pwm_PWMRemove_size 7 -#define wippersnapper_pwm_PWMWriteDutyCycleMulti_size 80 -#define wippersnapper_pwm_PWMWriteDutyCycle_size 18 -#define wippersnapper_pwm_PWMWriteFrequency_size 18 +#define wippersnapper_pwm_PWMWrite_size 18 #ifdef __cplusplus } /* extern "C" */ diff --git a/src/protos/servo.pb.c b/src/protos/servo.pb.c index 902cce097..9b30a2536 100644 --- a/src/protos/servo.pb.c +++ b/src/protos/servo.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_servo_ServoB2D, wippersnapper_servo_ServoB2D, AUTO) + + +PB_BIND(wippersnapper_servo_ServoD2B, wippersnapper_servo_ServoD2B, AUTO) + + PB_BIND(wippersnapper_servo_ServoAdd, wippersnapper_servo_ServoAdd, AUTO) diff --git a/src/protos/servo.pb.h b/src/protos/servo.pb.h index 5471c9f55..891f9096c 100644 --- a/src/protos/servo.pb.h +++ b/src/protos/servo.pb.h @@ -26,6 +26,15 @@ typedef struct _wippersnapper_servo_ServoAdded { char servo_pin[6]; /* * The name of pin we're responding about. */ } wippersnapper_servo_ServoAdded; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_servo_ServoD2B { + pb_size_t which_payload; + union { + wippersnapper_servo_ServoAdded servo_added; + } payload; +} wippersnapper_servo_ServoD2B; + /* * ServoRemove represents a request to detach a servo from a pin and de-initialize the pin for other uses. */ typedef struct _wippersnapper_servo_ServoRemove { @@ -43,16 +52,31 @@ typedef struct _wippersnapper_servo_ServoWrite { int32_t pulse_width; /* * The pulse width to write to the servo, in uS * */ } wippersnapper_servo_ServoWrite; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_servo_ServoB2D { + pb_size_t which_payload; + union { + wippersnapper_servo_ServoAdd servo_add; + wippersnapper_servo_ServoRemove servo_remove; + wippersnapper_servo_ServoWrite servo_write; + } payload; +} wippersnapper_servo_ServoB2D; + #ifdef __cplusplus extern "C" { #endif /* Initializer values for message structs */ +#define wippersnapper_servo_ServoB2D_init_default {0, {wippersnapper_servo_ServoAdd_init_default}} +#define wippersnapper_servo_ServoD2B_init_default {0, {wippersnapper_servo_ServoAdded_init_default}} #define wippersnapper_servo_ServoAdd_init_default {"", 0, 0, 0} #define wippersnapper_servo_ServoAdded_init_default {0, ""} #define wippersnapper_servo_ServoRemove_init_default {""} #define wippersnapper_servo_ServoWrite_init_default {"", 0} +#define wippersnapper_servo_ServoB2D_init_zero {0, {wippersnapper_servo_ServoAdd_init_zero}} +#define wippersnapper_servo_ServoD2B_init_zero {0, {wippersnapper_servo_ServoAdded_init_zero}} #define wippersnapper_servo_ServoAdd_init_zero {"", 0, 0, 0} #define wippersnapper_servo_ServoAdded_init_zero {0, ""} #define wippersnapper_servo_ServoRemove_init_zero {""} @@ -65,11 +89,31 @@ extern "C" { #define wippersnapper_servo_ServoAdd_max_pulse_width_tag 4 #define wippersnapper_servo_ServoAdded_attach_success_tag 1 #define wippersnapper_servo_ServoAdded_servo_pin_tag 2 +#define wippersnapper_servo_ServoD2B_servo_added_tag 10 #define wippersnapper_servo_ServoRemove_servo_pin_tag 1 #define wippersnapper_servo_ServoWrite_servo_pin_tag 1 #define wippersnapper_servo_ServoWrite_pulse_width_tag 2 +#define wippersnapper_servo_ServoB2D_servo_add_tag 10 +#define wippersnapper_servo_ServoB2D_servo_remove_tag 11 +#define wippersnapper_servo_ServoB2D_servo_write_tag 12 /* Struct field encoding specification for nanopb */ +#define wippersnapper_servo_ServoB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,servo_add,payload.servo_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,servo_remove,payload.servo_remove), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,servo_write,payload.servo_write), 12) +#define wippersnapper_servo_ServoB2D_CALLBACK NULL +#define wippersnapper_servo_ServoB2D_DEFAULT NULL +#define wippersnapper_servo_ServoB2D_payload_servo_add_MSGTYPE wippersnapper_servo_ServoAdd +#define wippersnapper_servo_ServoB2D_payload_servo_remove_MSGTYPE wippersnapper_servo_ServoRemove +#define wippersnapper_servo_ServoB2D_payload_servo_write_MSGTYPE wippersnapper_servo_ServoWrite + +#define wippersnapper_servo_ServoD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,servo_added,payload.servo_added), 10) +#define wippersnapper_servo_ServoD2B_CALLBACK NULL +#define wippersnapper_servo_ServoD2B_DEFAULT NULL +#define wippersnapper_servo_ServoD2B_payload_servo_added_MSGTYPE wippersnapper_servo_ServoAdded + #define wippersnapper_servo_ServoAdd_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, servo_pin, 1) \ X(a, STATIC, SINGULAR, INT32, servo_freq, 2) \ @@ -95,21 +139,27 @@ X(a, STATIC, SINGULAR, INT32, pulse_width, 2) #define wippersnapper_servo_ServoWrite_CALLBACK NULL #define wippersnapper_servo_ServoWrite_DEFAULT NULL +extern const pb_msgdesc_t wippersnapper_servo_ServoB2D_msg; +extern const pb_msgdesc_t wippersnapper_servo_ServoD2B_msg; extern const pb_msgdesc_t wippersnapper_servo_ServoAdd_msg; extern const pb_msgdesc_t wippersnapper_servo_ServoAdded_msg; extern const pb_msgdesc_t wippersnapper_servo_ServoRemove_msg; extern const pb_msgdesc_t wippersnapper_servo_ServoWrite_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_servo_ServoB2D_fields &wippersnapper_servo_ServoB2D_msg +#define wippersnapper_servo_ServoD2B_fields &wippersnapper_servo_ServoD2B_msg #define wippersnapper_servo_ServoAdd_fields &wippersnapper_servo_ServoAdd_msg #define wippersnapper_servo_ServoAdded_fields &wippersnapper_servo_ServoAdded_msg #define wippersnapper_servo_ServoRemove_fields &wippersnapper_servo_ServoRemove_msg #define wippersnapper_servo_ServoWrite_fields &wippersnapper_servo_ServoWrite_msg /* Maximum encoded size of messages (where known) */ -#define WIPPERSNAPPER_SERVO_SERVO_PB_H_MAX_SIZE wippersnapper_servo_ServoAdd_size +#define WIPPERSNAPPER_SERVO_SERVO_PB_H_MAX_SIZE wippersnapper_servo_ServoB2D_size #define wippersnapper_servo_ServoAdd_size 40 #define wippersnapper_servo_ServoAdded_size 9 +#define wippersnapper_servo_ServoB2D_size 42 +#define wippersnapper_servo_ServoD2B_size 11 #define wippersnapper_servo_ServoRemove_size 7 #define wippersnapper_servo_ServoWrite_size 18 diff --git a/src/protos/signal.pb.h b/src/protos/signal.pb.h index c328eea49..4905d8c05 100644 --- a/src/protos/signal.pb.h +++ b/src/protos/signal.pb.h @@ -4,14 +4,12 @@ #ifndef PB_WIPPERSNAPPER_SIGNAL_SIGNAL_PB_H_INCLUDED #define PB_WIPPERSNAPPER_SIGNAL_SIGNAL_PB_H_INCLUDED #include -#include "analogio.pb.h" +#include "error.pb.h" #include "checkin.pb.h" +#include "analogio.pb.h" #include "digitalio.pb.h" #include "ds18x20.pb.h" -#include "error.pb.h" -#include "gps.pb.h" #include "i2c.pb.h" -#include "i2c_output.pb.h" #include "pixels.pb.h" #include "pwm.pb.h" #include "servo.pb.h" @@ -25,86 +23,46 @@ /* BrokerToDevice The BrokerToDevice message is sent from the broker to the device. It contains a oneof payload, which is a union of all the possible - messages that can be sent from the broker to a device. */ + message-types that can be sent from the broker to a device. */ typedef struct _wippersnapper_signal_BrokerToDevice { pb_callback_t cb_payload; pb_size_t which_payload; union { - /* digitalio.proto */ - wippersnapper_digitalio_DigitalIOAdd digitalio_add; - wippersnapper_digitalio_DigitalIORemove digitalio_remove; - wippersnapper_digitalio_DigitalIOEvent digitalio_event; - wippersnapper_digitalio_DigitalIOWrite digitalio_write; - /* analogio.proto */ - wippersnapper_analogio_AnalogIOAdd analogio_add; - wippersnapper_analogio_AnalogIORemove analogio_remove; - /* checkin.proto */ - wippersnapper_checkin_CheckinResponse checkin_response; - /* servo.proto */ - wippersnapper_servo_ServoAdd servo_add; - wippersnapper_servo_ServoRemove servo_remove; - wippersnapper_servo_ServoWrite servo_write; - /* pwm.proto */ - wippersnapper_pwm_PWMAdd pwm_add; - wippersnapper_pwm_PWMRemove pwm_remove; - wippersnapper_pwm_PWMWriteDutyCycle pwm_write_duty; - wippersnapper_pwm_PWMWriteDutyCycleMulti pwm_write_duty_multi; - wippersnapper_pwm_PWMWriteFrequency pwm_write_freq; - /* pixels.proto */ - wippersnapper_pixels_PixelsAdd pixels_add; - wippersnapper_pixels_PixelsRemove pixels_remove; - wippersnapper_pixels_PixelsWrite pixels_write; - /* ds18x20.proto */ - wippersnapper_ds18x20_Ds18x20Add ds18x20_add; - wippersnapper_ds18x20_Ds18x20Remove ds18x20_remove; - /* uart.proto */ - wippersnapper_uart_UartAdd uart_add; - wippersnapper_uart_UartRemove uart_remove; - wippersnapper_uart_UartWrite uart_write; - /* i2c.proto */ - wippersnapper_i2c_I2cBusScan i2c_bus_scan; - wippersnapper_i2c_I2cDeviceAddOrReplace i2c_device_add_replace; - wippersnapper_i2c_I2cDeviceRemove i2c_device_remove; - wippersnapper_i2c_I2cDeviceOutputWrite i2c_device_output_write; - /* error.proto */ + /* System Events */ wippersnapper_error_Error error; + /* Device Interactions */ + wippersnapper_checkin_CheckinB2D checkin; + /* Component Interactions */ + wippersnapper_digitalio_DigitalIOB2D digitalio; + wippersnapper_analogio_AnalogIOB2D analogio; + wippersnapper_servo_ServoB2D servo; + wippersnapper_pwm_PWMB2D pwm; + wippersnapper_pixels_PixelsB2D pixels; + wippersnapper_ds18x20_Ds18x20B2D ds18x20; + wippersnapper_uart_UartB2D uart; + wippersnapper_i2c_I2cB2D i2c; /* wippersnapper.gps.GPSB2D gps = xx; */ } payload; } wippersnapper_signal_BrokerToDevice; /* DeviceToBroker The DeviceToBroker message is sent from the device to the broker. It contains a oneof payload, which is a union of all the possible - messages that can be sent from a device to the broker. */ + message-types that can be sent from a device to the broker. */ typedef struct _wippersnapper_signal_DeviceToBroker { pb_callback_t cb_payload; pb_size_t which_payload; union { - /* digitalio.proto */ - wippersnapper_digitalio_DigitalIOEvent digitalio_event; - /* analogio.proto */ - wippersnapper_analogio_AnalogIOEvent analogio_event; - /* checkin.proto */ - wippersnapper_checkin_CheckinRequest checkin_request; - /* servo.proto */ - wippersnapper_servo_ServoAdded servo_added; - /* pwm.proto */ - wippersnapper_pwm_PWMAdded pwm_added; - /* pixels.proto */ - wippersnapper_pixels_PixelsAdded pixels_added; - /* ds18x20.proto */ - wippersnapper_ds18x20_Ds18x20Added ds18x20_added; - wippersnapper_ds18x20_Ds18x20Event ds18x20_event; - /* uart.proto */ - wippersnapper_uart_UartAdded uart_added; - wippersnapper_uart_UartWritten uart_written; - wippersnapper_uart_UartInputEvent uart_input_event; - /* i2c.proto */ - wippersnapper_i2c_I2cBusScanned i2c_bus_scanned; - wippersnapper_i2c_I2cDeviceAddedOrReplaced i2c_device_added_replaced; - wippersnapper_i2c_I2cDeviceRemoved i2c_device_removed; - wippersnapper_i2c_I2cDeviceEvent i2c_device_event; - /* gps.proto */ - wippersnapper_gps_GPSEvent gps_event; + /* Device Interactions */ + wippersnapper_checkin_CheckinD2B checkin; + /* Component Interactions */ + wippersnapper_digitalio_DigitalIOD2B digitalio; + wippersnapper_analogio_AnalogIOD2B analogio; + wippersnapper_servo_ServoD2B servo; + wippersnapper_pwm_PWMD2B pwm; + wippersnapper_pixels_PixelsD2B pixels; + wippersnapper_ds18x20_Ds18x20D2B ds18x20; + wippersnapper_uart_UartD2B uart; + wippersnapper_i2c_I2cD2B i2c; /* wippersnapper.gps.GPSD2B gps = xx; */ } payload; } wippersnapper_signal_DeviceToBroker; @@ -114,153 +72,78 @@ extern "C" { #endif /* Initializer values for message structs */ -#define wippersnapper_signal_BrokerToDevice_init_default {{{NULL}, NULL}, 0, {wippersnapper_digitalio_DigitalIOAdd_init_default}} -#define wippersnapper_signal_DeviceToBroker_init_default {{{NULL}, NULL}, 0, {wippersnapper_digitalio_DigitalIOEvent_init_default}} -#define wippersnapper_signal_BrokerToDevice_init_zero {{{NULL}, NULL}, 0, {wippersnapper_digitalio_DigitalIOAdd_init_zero}} -#define wippersnapper_signal_DeviceToBroker_init_zero {{{NULL}, NULL}, 0, {wippersnapper_digitalio_DigitalIOEvent_init_zero}} +#define wippersnapper_signal_BrokerToDevice_init_default {{{NULL}, NULL}, 0, {wippersnapper_error_Error_init_default}} +#define wippersnapper_signal_DeviceToBroker_init_default {{{NULL}, NULL}, 0, {wippersnapper_checkin_CheckinD2B_init_default}} +#define wippersnapper_signal_BrokerToDevice_init_zero {{{NULL}, NULL}, 0, {wippersnapper_error_Error_init_zero}} +#define wippersnapper_signal_DeviceToBroker_init_zero {{{NULL}, NULL}, 0, {wippersnapper_checkin_CheckinD2B_init_zero}} /* Field tags (for use in manual encoding/decoding) */ -#define wippersnapper_signal_BrokerToDevice_digitalio_add_tag 10 -#define wippersnapper_signal_BrokerToDevice_digitalio_remove_tag 11 -#define wippersnapper_signal_BrokerToDevice_digitalio_event_tag 12 -#define wippersnapper_signal_BrokerToDevice_digitalio_write_tag 13 -#define wippersnapper_signal_BrokerToDevice_analogio_add_tag 20 -#define wippersnapper_signal_BrokerToDevice_analogio_remove_tag 21 -#define wippersnapper_signal_BrokerToDevice_checkin_response_tag 30 -#define wippersnapper_signal_BrokerToDevice_servo_add_tag 40 -#define wippersnapper_signal_BrokerToDevice_servo_remove_tag 41 -#define wippersnapper_signal_BrokerToDevice_servo_write_tag 42 -#define wippersnapper_signal_BrokerToDevice_pwm_add_tag 50 -#define wippersnapper_signal_BrokerToDevice_pwm_remove_tag 51 -#define wippersnapper_signal_BrokerToDevice_pwm_write_duty_tag 52 -#define wippersnapper_signal_BrokerToDevice_pwm_write_duty_multi_tag 53 -#define wippersnapper_signal_BrokerToDevice_pwm_write_freq_tag 54 -#define wippersnapper_signal_BrokerToDevice_pixels_add_tag 60 -#define wippersnapper_signal_BrokerToDevice_pixels_remove_tag 61 -#define wippersnapper_signal_BrokerToDevice_pixels_write_tag 62 -#define wippersnapper_signal_BrokerToDevice_ds18x20_add_tag 70 -#define wippersnapper_signal_BrokerToDevice_ds18x20_remove_tag 71 -#define wippersnapper_signal_BrokerToDevice_uart_add_tag 80 -#define wippersnapper_signal_BrokerToDevice_uart_remove_tag 81 -#define wippersnapper_signal_BrokerToDevice_uart_write_tag 82 -#define wippersnapper_signal_BrokerToDevice_i2c_bus_scan_tag 90 -#define wippersnapper_signal_BrokerToDevice_i2c_device_add_replace_tag 91 -#define wippersnapper_signal_BrokerToDevice_i2c_device_remove_tag 92 -#define wippersnapper_signal_BrokerToDevice_i2c_device_output_write_tag 93 -#define wippersnapper_signal_BrokerToDevice_error_tag 100 -#define wippersnapper_signal_DeviceToBroker_digitalio_event_tag 10 -#define wippersnapper_signal_DeviceToBroker_analogio_event_tag 20 -#define wippersnapper_signal_DeviceToBroker_checkin_request_tag 30 -#define wippersnapper_signal_DeviceToBroker_servo_added_tag 40 -#define wippersnapper_signal_DeviceToBroker_pwm_added_tag 50 -#define wippersnapper_signal_DeviceToBroker_pixels_added_tag 60 -#define wippersnapper_signal_DeviceToBroker_ds18x20_added_tag 70 -#define wippersnapper_signal_DeviceToBroker_ds18x20_event_tag 80 -#define wippersnapper_signal_DeviceToBroker_uart_added_tag 90 -#define wippersnapper_signal_DeviceToBroker_uart_written_tag 91 -#define wippersnapper_signal_DeviceToBroker_uart_input_event_tag 92 -#define wippersnapper_signal_DeviceToBroker_i2c_bus_scanned_tag 110 -#define wippersnapper_signal_DeviceToBroker_i2c_device_added_replaced_tag 111 -#define wippersnapper_signal_DeviceToBroker_i2c_device_removed_tag 112 -#define wippersnapper_signal_DeviceToBroker_i2c_device_event_tag 113 -#define wippersnapper_signal_DeviceToBroker_gps_event_tag 120 +#define wippersnapper_signal_BrokerToDevice_error_tag 10 +#define wippersnapper_signal_BrokerToDevice_checkin_tag 20 +#define wippersnapper_signal_BrokerToDevice_digitalio_tag 30 +#define wippersnapper_signal_BrokerToDevice_analogio_tag 31 +#define wippersnapper_signal_BrokerToDevice_servo_tag 32 +#define wippersnapper_signal_BrokerToDevice_pwm_tag 33 +#define wippersnapper_signal_BrokerToDevice_pixels_tag 34 +#define wippersnapper_signal_BrokerToDevice_ds18x20_tag 35 +#define wippersnapper_signal_BrokerToDevice_uart_tag 36 +#define wippersnapper_signal_BrokerToDevice_i2c_tag 37 +#define wippersnapper_signal_DeviceToBroker_checkin_tag 20 +#define wippersnapper_signal_DeviceToBroker_digitalio_tag 30 +#define wippersnapper_signal_DeviceToBroker_analogio_tag 31 +#define wippersnapper_signal_DeviceToBroker_servo_tag 32 +#define wippersnapper_signal_DeviceToBroker_pwm_tag 33 +#define wippersnapper_signal_DeviceToBroker_pixels_tag 34 +#define wippersnapper_signal_DeviceToBroker_ds18x20_tag 35 +#define wippersnapper_signal_DeviceToBroker_uart_tag 36 +#define wippersnapper_signal_DeviceToBroker_i2c_tag 37 /* Struct field encoding specification for nanopb */ #define wippersnapper_signal_BrokerToDevice_FIELDLIST(X, a) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio_add,payload.digitalio_add), 10) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio_remove,payload.digitalio_remove), 11) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio_event,payload.digitalio_event), 12) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio_write,payload.digitalio_write), 13) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,analogio_add,payload.analogio_add), 20) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,analogio_remove,payload.analogio_remove), 21) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,checkin_response,payload.checkin_response), 30) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,servo_add,payload.servo_add), 40) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,servo_remove,payload.servo_remove), 41) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,servo_write,payload.servo_write), 42) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm_add,payload.pwm_add), 50) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm_remove,payload.pwm_remove), 51) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm_write_duty,payload.pwm_write_duty), 52) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm_write_duty_multi,payload.pwm_write_duty_multi), 53) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm_write_freq,payload.pwm_write_freq), 54) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels_add,payload.pixels_add), 60) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels_remove,payload.pixels_remove), 61) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels_write,payload.pixels_write), 62) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20_add,payload.ds18x20_add), 70) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20_remove,payload.ds18x20_remove), 71) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart_add,payload.uart_add), 80) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart_remove,payload.uart_remove), 81) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart_write,payload.uart_write), 82) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_bus_scan,payload.i2c_bus_scan), 90) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_device_add_replace,payload.i2c_device_add_replace), 91) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_device_remove,payload.i2c_device_remove), 92) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_device_output_write,payload.i2c_device_output_write), 93) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,error,payload.error), 100) +X(a, STATIC, ONEOF, MSG_W_CB, (payload,error,payload.error), 10) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,checkin,payload.checkin), 20) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio,payload.digitalio), 30) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,analogio,payload.analogio), 31) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,servo,payload.servo), 32) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm,payload.pwm), 33) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels,payload.pixels), 34) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20,payload.ds18x20), 35) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart,payload.uart), 36) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c,payload.i2c), 37) #define wippersnapper_signal_BrokerToDevice_CALLBACK NULL #define wippersnapper_signal_BrokerToDevice_DEFAULT NULL -#define wippersnapper_signal_BrokerToDevice_payload_digitalio_add_MSGTYPE wippersnapper_digitalio_DigitalIOAdd -#define wippersnapper_signal_BrokerToDevice_payload_digitalio_remove_MSGTYPE wippersnapper_digitalio_DigitalIORemove -#define wippersnapper_signal_BrokerToDevice_payload_digitalio_event_MSGTYPE wippersnapper_digitalio_DigitalIOEvent -#define wippersnapper_signal_BrokerToDevice_payload_digitalio_write_MSGTYPE wippersnapper_digitalio_DigitalIOWrite -#define wippersnapper_signal_BrokerToDevice_payload_analogio_add_MSGTYPE wippersnapper_analogio_AnalogIOAdd -#define wippersnapper_signal_BrokerToDevice_payload_analogio_remove_MSGTYPE wippersnapper_analogio_AnalogIORemove -#define wippersnapper_signal_BrokerToDevice_payload_checkin_response_MSGTYPE wippersnapper_checkin_CheckinResponse -#define wippersnapper_signal_BrokerToDevice_payload_servo_add_MSGTYPE wippersnapper_servo_ServoAdd -#define wippersnapper_signal_BrokerToDevice_payload_servo_remove_MSGTYPE wippersnapper_servo_ServoRemove -#define wippersnapper_signal_BrokerToDevice_payload_servo_write_MSGTYPE wippersnapper_servo_ServoWrite -#define wippersnapper_signal_BrokerToDevice_payload_pwm_add_MSGTYPE wippersnapper_pwm_PWMAdd -#define wippersnapper_signal_BrokerToDevice_payload_pwm_remove_MSGTYPE wippersnapper_pwm_PWMRemove -#define wippersnapper_signal_BrokerToDevice_payload_pwm_write_duty_MSGTYPE wippersnapper_pwm_PWMWriteDutyCycle -#define wippersnapper_signal_BrokerToDevice_payload_pwm_write_duty_multi_MSGTYPE wippersnapper_pwm_PWMWriteDutyCycleMulti -#define wippersnapper_signal_BrokerToDevice_payload_pwm_write_freq_MSGTYPE wippersnapper_pwm_PWMWriteFrequency -#define wippersnapper_signal_BrokerToDevice_payload_pixels_add_MSGTYPE wippersnapper_pixels_PixelsAdd -#define wippersnapper_signal_BrokerToDevice_payload_pixels_remove_MSGTYPE wippersnapper_pixels_PixelsRemove -#define wippersnapper_signal_BrokerToDevice_payload_pixels_write_MSGTYPE wippersnapper_pixels_PixelsWrite -#define wippersnapper_signal_BrokerToDevice_payload_ds18x20_add_MSGTYPE wippersnapper_ds18x20_Ds18x20Add -#define wippersnapper_signal_BrokerToDevice_payload_ds18x20_remove_MSGTYPE wippersnapper_ds18x20_Ds18x20Remove -#define wippersnapper_signal_BrokerToDevice_payload_uart_add_MSGTYPE wippersnapper_uart_UartAdd -#define wippersnapper_signal_BrokerToDevice_payload_uart_remove_MSGTYPE wippersnapper_uart_UartRemove -#define wippersnapper_signal_BrokerToDevice_payload_uart_write_MSGTYPE wippersnapper_uart_UartWrite -#define wippersnapper_signal_BrokerToDevice_payload_i2c_bus_scan_MSGTYPE wippersnapper_i2c_I2cBusScan -#define wippersnapper_signal_BrokerToDevice_payload_i2c_device_add_replace_MSGTYPE wippersnapper_i2c_I2cDeviceAddOrReplace -#define wippersnapper_signal_BrokerToDevice_payload_i2c_device_remove_MSGTYPE wippersnapper_i2c_I2cDeviceRemove -#define wippersnapper_signal_BrokerToDevice_payload_i2c_device_output_write_MSGTYPE wippersnapper_i2c_I2cDeviceOutputWrite #define wippersnapper_signal_BrokerToDevice_payload_error_MSGTYPE wippersnapper_error_Error +#define wippersnapper_signal_BrokerToDevice_payload_checkin_MSGTYPE wippersnapper_checkin_CheckinB2D +#define wippersnapper_signal_BrokerToDevice_payload_digitalio_MSGTYPE wippersnapper_digitalio_DigitalIOB2D +#define wippersnapper_signal_BrokerToDevice_payload_analogio_MSGTYPE wippersnapper_analogio_AnalogIOB2D +#define wippersnapper_signal_BrokerToDevice_payload_servo_MSGTYPE wippersnapper_servo_ServoB2D +#define wippersnapper_signal_BrokerToDevice_payload_pwm_MSGTYPE wippersnapper_pwm_PWMB2D +#define wippersnapper_signal_BrokerToDevice_payload_pixels_MSGTYPE wippersnapper_pixels_PixelsB2D +#define wippersnapper_signal_BrokerToDevice_payload_ds18x20_MSGTYPE wippersnapper_ds18x20_Ds18x20B2D +#define wippersnapper_signal_BrokerToDevice_payload_uart_MSGTYPE wippersnapper_uart_UartB2D +#define wippersnapper_signal_BrokerToDevice_payload_i2c_MSGTYPE wippersnapper_i2c_I2cB2D #define wippersnapper_signal_DeviceToBroker_FIELDLIST(X, a) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio_event,payload.digitalio_event), 10) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,analogio_event,payload.analogio_event), 20) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,checkin_request,payload.checkin_request), 30) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,servo_added,payload.servo_added), 40) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm_added,payload.pwm_added), 50) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels_added,payload.pixels_added), 60) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20_added,payload.ds18x20_added), 70) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20_event,payload.ds18x20_event), 80) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart_added,payload.uart_added), 90) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart_written,payload.uart_written), 91) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart_input_event,payload.uart_input_event), 92) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_bus_scanned,payload.i2c_bus_scanned), 110) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_device_added_replaced,payload.i2c_device_added_replaced), 111) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_device_removed,payload.i2c_device_removed), 112) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c_device_event,payload.i2c_device_event), 113) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,gps_event,payload.gps_event), 120) +X(a, STATIC, ONEOF, MSG_W_CB, (payload,checkin,payload.checkin), 20) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,digitalio,payload.digitalio), 30) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,analogio,payload.analogio), 31) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,servo,payload.servo), 32) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm,payload.pwm), 33) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels,payload.pixels), 34) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20,payload.ds18x20), 35) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart,payload.uart), 36) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c,payload.i2c), 37) #define wippersnapper_signal_DeviceToBroker_CALLBACK NULL #define wippersnapper_signal_DeviceToBroker_DEFAULT NULL -#define wippersnapper_signal_DeviceToBroker_payload_digitalio_event_MSGTYPE wippersnapper_digitalio_DigitalIOEvent -#define wippersnapper_signal_DeviceToBroker_payload_analogio_event_MSGTYPE wippersnapper_analogio_AnalogIOEvent -#define wippersnapper_signal_DeviceToBroker_payload_checkin_request_MSGTYPE wippersnapper_checkin_CheckinRequest -#define wippersnapper_signal_DeviceToBroker_payload_servo_added_MSGTYPE wippersnapper_servo_ServoAdded -#define wippersnapper_signal_DeviceToBroker_payload_pwm_added_MSGTYPE wippersnapper_pwm_PWMAdded -#define wippersnapper_signal_DeviceToBroker_payload_pixels_added_MSGTYPE wippersnapper_pixels_PixelsAdded -#define wippersnapper_signal_DeviceToBroker_payload_ds18x20_added_MSGTYPE wippersnapper_ds18x20_Ds18x20Added -#define wippersnapper_signal_DeviceToBroker_payload_ds18x20_event_MSGTYPE wippersnapper_ds18x20_Ds18x20Event -#define wippersnapper_signal_DeviceToBroker_payload_uart_added_MSGTYPE wippersnapper_uart_UartAdded -#define wippersnapper_signal_DeviceToBroker_payload_uart_written_MSGTYPE wippersnapper_uart_UartWritten -#define wippersnapper_signal_DeviceToBroker_payload_uart_input_event_MSGTYPE wippersnapper_uart_UartInputEvent -#define wippersnapper_signal_DeviceToBroker_payload_i2c_bus_scanned_MSGTYPE wippersnapper_i2c_I2cBusScanned -#define wippersnapper_signal_DeviceToBroker_payload_i2c_device_added_replaced_MSGTYPE wippersnapper_i2c_I2cDeviceAddedOrReplaced -#define wippersnapper_signal_DeviceToBroker_payload_i2c_device_removed_MSGTYPE wippersnapper_i2c_I2cDeviceRemoved -#define wippersnapper_signal_DeviceToBroker_payload_i2c_device_event_MSGTYPE wippersnapper_i2c_I2cDeviceEvent -#define wippersnapper_signal_DeviceToBroker_payload_gps_event_MSGTYPE wippersnapper_gps_GPSEvent +#define wippersnapper_signal_DeviceToBroker_payload_checkin_MSGTYPE wippersnapper_checkin_CheckinD2B +#define wippersnapper_signal_DeviceToBroker_payload_digitalio_MSGTYPE wippersnapper_digitalio_DigitalIOD2B +#define wippersnapper_signal_DeviceToBroker_payload_analogio_MSGTYPE wippersnapper_analogio_AnalogIOD2B +#define wippersnapper_signal_DeviceToBroker_payload_servo_MSGTYPE wippersnapper_servo_ServoD2B +#define wippersnapper_signal_DeviceToBroker_payload_pwm_MSGTYPE wippersnapper_pwm_PWMD2B +#define wippersnapper_signal_DeviceToBroker_payload_pixels_MSGTYPE wippersnapper_pixels_PixelsD2B +#define wippersnapper_signal_DeviceToBroker_payload_ds18x20_MSGTYPE wippersnapper_ds18x20_Ds18x20D2B +#define wippersnapper_signal_DeviceToBroker_payload_uart_MSGTYPE wippersnapper_uart_UartD2B +#define wippersnapper_signal_DeviceToBroker_payload_i2c_MSGTYPE wippersnapper_i2c_I2cD2B extern const pb_msgdesc_t wippersnapper_signal_BrokerToDevice_msg; extern const pb_msgdesc_t wippersnapper_signal_DeviceToBroker_msg; @@ -270,17 +153,17 @@ extern const pb_msgdesc_t wippersnapper_signal_DeviceToBroker_msg; #define wippersnapper_signal_DeviceToBroker_fields &wippersnapper_signal_DeviceToBroker_msg /* Maximum encoded size of messages (where known) */ -#if defined(wippersnapper_digitalio_DigitalIOEvent_size) && defined(wippersnapper_digitalio_DigitalIOWrite_size) && defined(wippersnapper_uart_UartAdd_size) && defined(wippersnapper_uart_UartWrite_size) -union wippersnapper_signal_BrokerToDevice_payload_size_union {char f12[(6 + wippersnapper_digitalio_DigitalIOEvent_size)]; char f13[(6 + wippersnapper_digitalio_DigitalIOWrite_size)]; char f80[(7 + wippersnapper_uart_UartAdd_size)]; char f82[(7 + wippersnapper_uart_UartWrite_size)]; char f0[1921];}; +#if defined(wippersnapper_checkin_CheckinB2D_size) && defined(wippersnapper_digitalio_DigitalIOB2D_size) && defined(wippersnapper_uart_UartB2D_size) +union wippersnapper_signal_BrokerToDevice_payload_size_union {char f20[(7 + wippersnapper_checkin_CheckinB2D_size)]; char f30[(7 + wippersnapper_digitalio_DigitalIOB2D_size)]; char f36[(7 + wippersnapper_uart_UartB2D_size)]; char f0[1924];}; #endif -#if defined(wippersnapper_digitalio_DigitalIOEvent_size) && defined(wippersnapper_analogio_AnalogIOEvent_size) && defined(wippersnapper_ds18x20_Ds18x20Event_size) && defined(wippersnapper_uart_UartInputEvent_size) && defined(wippersnapper_i2c_I2cDeviceEvent_size) -union wippersnapper_signal_DeviceToBroker_payload_size_union {char f10[(6 + wippersnapper_digitalio_DigitalIOEvent_size)]; char f20[(7 + wippersnapper_analogio_AnalogIOEvent_size)]; char f80[(7 + wippersnapper_ds18x20_Ds18x20Event_size)]; char f92[(7 + wippersnapper_uart_UartInputEvent_size)]; char f113[(7 + wippersnapper_i2c_I2cDeviceEvent_size)]; char f0[6246];}; +#if defined(wippersnapper_digitalio_DigitalIOD2B_size) && defined(wippersnapper_analogio_AnalogIOD2B_size) && defined(wippersnapper_ds18x20_Ds18x20D2B_size) && defined(wippersnapper_uart_UartD2B_size) && defined(wippersnapper_i2c_I2cD2B_size) +union wippersnapper_signal_DeviceToBroker_payload_size_union {char f30[(7 + wippersnapper_digitalio_DigitalIOD2B_size)]; char f31[(7 + wippersnapper_analogio_AnalogIOD2B_size)]; char f35[(7 + wippersnapper_ds18x20_Ds18x20D2B_size)]; char f36[(7 + wippersnapper_uart_UartD2B_size)]; char f37[(7 + wippersnapper_i2c_I2cD2B_size)]; char f0[96];}; #endif -#if defined(wippersnapper_digitalio_DigitalIOEvent_size) && defined(wippersnapper_digitalio_DigitalIOWrite_size) && defined(wippersnapper_uart_UartAdd_size) && defined(wippersnapper_uart_UartWrite_size) +#if defined(wippersnapper_checkin_CheckinB2D_size) && defined(wippersnapper_digitalio_DigitalIOB2D_size) && defined(wippersnapper_uart_UartB2D_size) #define WIPPERSNAPPER_SIGNAL_SIGNAL_PB_H_MAX_SIZE wippersnapper_signal_BrokerToDevice_size #define wippersnapper_signal_BrokerToDevice_size (0 + sizeof(union wippersnapper_signal_BrokerToDevice_payload_size_union)) #endif -#if defined(wippersnapper_digitalio_DigitalIOEvent_size) && defined(wippersnapper_analogio_AnalogIOEvent_size) && defined(wippersnapper_ds18x20_Ds18x20Event_size) && defined(wippersnapper_uart_UartInputEvent_size) && defined(wippersnapper_i2c_I2cDeviceEvent_size) +#if defined(wippersnapper_digitalio_DigitalIOD2B_size) && defined(wippersnapper_analogio_AnalogIOD2B_size) && defined(wippersnapper_ds18x20_Ds18x20D2B_size) && defined(wippersnapper_uart_UartD2B_size) && defined(wippersnapper_i2c_I2cD2B_size) #define wippersnapper_signal_DeviceToBroker_size (0 + sizeof(union wippersnapper_signal_DeviceToBroker_payload_size_union)) #endif diff --git a/src/protos/uart.pb.c b/src/protos/uart.pb.c index 4490968a3..12dda9748 100644 --- a/src/protos/uart.pb.c +++ b/src/protos/uart.pb.c @@ -6,6 +6,12 @@ #error Regenerate this file with the current version of nanopb generator. #endif +PB_BIND(wippersnapper_uart_UartB2D, wippersnapper_uart_UartB2D, 2) + + +PB_BIND(wippersnapper_uart_UartD2B, wippersnapper_uart_UartD2B, 2) + + PB_BIND(wippersnapper_uart_UartSerialConfig, wippersnapper_uart_UartSerialConfig, AUTO) diff --git a/src/protos/uart.pb.h b/src/protos/uart.pb.h index b47509530..bcd0471c4 100644 --- a/src/protos/uart.pb.h +++ b/src/protos/uart.pb.h @@ -67,11 +67,12 @@ typedef enum _wippersnapper_uart_GenericDeviceLineEnding { /* Struct definitions */ /* * - UartSerialConfig represents a message to configure the Serial (eg: HardwareSerial, SoftwareSerial). + UartSerialConfig represents a message to configure the Serial port (eg: Hardware Serial, Software Serial). This message is never sent directly, it is packed inside UartAdd. */ typedef struct _wippersnapper_uart_UartSerialConfig { char pin_rx[16]; /* * The pin on which to receive on. */ char pin_tx[16]; /* * The pin on which to transmit with. */ + pb_callback_t device_name; /* * (For CPython ONLY) The device name, i.e: /dev/ttyUSB0. */ uint32_t uart_nbr; /* * The UART port number to use, eg: 0, 1, 2, etc. */ uint32_t baud_rate; /* * The desired baudrate, in bits per second. */ wippersnapper_uart_UartPacketFormat format; /* * The data, parity, and stop bits. */ @@ -87,8 +88,8 @@ typedef struct _wippersnapper_uart_GenericUartInputConfig { pb_callback_t name; /* * The name used to identify the device. */ wippersnapper_uart_GenericDeviceLineEnding line_ending; /* * The line ending used by the device. */ int32_t period; /* * The period to poll the device, in milliseconds */ - pb_size_t i2c_device_sensor_types_count; - wippersnapper_sensor_SensorType i2c_device_sensor_types[15]; /* * SI Types for each sensor on the I2c device. */ + pb_size_t sensor_types_count; + wippersnapper_sensor_SensorType sensor_types[15]; /* * SI Types for each sensor on the UART device. */ } wippersnapper_uart_GenericUartInputConfig; /* * @@ -104,8 +105,8 @@ typedef struct _wippersnapper_uart_TrinamicDynamixelConfig { typedef struct _wippersnapper_uart_PM25AQIConfig { bool is_pm1006; /* * True if the device is a PM1006 AQ sensor, Defaults to False. */ int32_t period; /* * The period to poll the device, in milliseconds */ - pb_size_t i2c_device_sensor_types_count; - wippersnapper_sensor_SensorType i2c_device_sensor_types[15]; /* * SI Types for each sensor on the I2c device. */ + pb_size_t sensor_types_count; + wippersnapper_sensor_SensorType sensor_types[15]; /* * SI Types for each sensor on the I2c device. */ } wippersnapper_uart_PM25AQIConfig; /* * @@ -170,6 +171,17 @@ typedef struct _wippersnapper_uart_UartWrite { } payload; } wippersnapper_uart_UartWrite; +/* * + BrokerToDevice message envelope */ +typedef struct _wippersnapper_uart_UartB2D { + pb_size_t which_payload; + union { + wippersnapper_uart_UartAdd uart_add; + wippersnapper_uart_UartRemove uart_remove; + wippersnapper_uart_UartWrite uart_write; + } payload; +} wippersnapper_uart_UartB2D; + /* * UartWritten represents the number of bytes written to a device.enum This message is sent from a device to IO to confirm that data has been written to the device. */ @@ -197,6 +209,17 @@ typedef struct _wippersnapper_uart_UartInputEvent { wippersnapper_sensor_SensorEvent events[15]; /* * Required, but optionally repeated, SensorEvent from a sensor. */ } wippersnapper_uart_UartInputEvent; +/* * + DeviceToBroker message envelope */ +typedef struct _wippersnapper_uart_UartD2B { + pb_size_t which_payload; + union { + wippersnapper_uart_UartAdded uart_added; + wippersnapper_uart_UartWritten uart_written; + wippersnapper_uart_UartInputEvent uart_input_event; + } payload; +} wippersnapper_uart_UartD2B; + #ifdef __cplusplus extern "C" { @@ -215,13 +238,15 @@ extern "C" { #define _wippersnapper_uart_GenericDeviceLineEnding_MAX wippersnapper_uart_GenericDeviceLineEnding_GENERIC_DEVICE_LINE_ENDING_TIMEOUT_1000MS #define _wippersnapper_uart_GenericDeviceLineEnding_ARRAYSIZE ((wippersnapper_uart_GenericDeviceLineEnding)(wippersnapper_uart_GenericDeviceLineEnding_GENERIC_DEVICE_LINE_ENDING_TIMEOUT_1000MS+1)) + + #define wippersnapper_uart_UartSerialConfig_format_ENUMTYPE wippersnapper_uart_UartPacketFormat #define wippersnapper_uart_GenericUartInputConfig_line_ending_ENUMTYPE wippersnapper_uart_GenericDeviceLineEnding -#define wippersnapper_uart_GenericUartInputConfig_i2c_device_sensor_types_ENUMTYPE wippersnapper_sensor_SensorType +#define wippersnapper_uart_GenericUartInputConfig_sensor_types_ENUMTYPE wippersnapper_sensor_SensorType -#define wippersnapper_uart_PM25AQIConfig_i2c_device_sensor_types_ENUMTYPE wippersnapper_sensor_SensorType +#define wippersnapper_uart_PM25AQIConfig_sensor_types_ENUMTYPE wippersnapper_sensor_SensorType #define wippersnapper_uart_UartDeviceConfig_device_type_ENUMTYPE wippersnapper_uart_UartDeviceType @@ -238,7 +263,9 @@ extern "C" { /* Initializer values for message structs */ -#define wippersnapper_uart_UartSerialConfig_init_default {"", "", 0, 0, _wippersnapper_uart_UartPacketFormat_MIN, 0, 0, 0} +#define wippersnapper_uart_UartB2D_init_default {0, {wippersnapper_uart_UartAdd_init_default}} +#define wippersnapper_uart_UartD2B_init_default {0, {wippersnapper_uart_UartAdded_init_default}} +#define wippersnapper_uart_UartSerialConfig_init_default {"", "", {{NULL}, NULL}, 0, 0, _wippersnapper_uart_UartPacketFormat_MIN, 0, 0, 0} #define wippersnapper_uart_GenericUartInputConfig_init_default {{{NULL}, NULL}, _wippersnapper_uart_GenericDeviceLineEnding_MIN, 0, 0, {_wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN}} #define wippersnapper_uart_TrinamicDynamixelConfig_init_default {0} #define wippersnapper_uart_PM25AQIConfig_init_default {0, 0, 0, {_wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN}} @@ -249,7 +276,9 @@ extern "C" { #define wippersnapper_uart_UartWrite_init_default {0, _wippersnapper_uart_UartDeviceType_MIN, "", 0, {{{NULL}, NULL}}} #define wippersnapper_uart_UartWritten_init_default {0, _wippersnapper_uart_UartDeviceType_MIN, "", 0} #define wippersnapper_uart_UartInputEvent_init_default {0, _wippersnapper_uart_UartDeviceType_MIN, "", 0, {wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default, wippersnapper_sensor_SensorEvent_init_default}} -#define wippersnapper_uart_UartSerialConfig_init_zero {"", "", 0, 0, _wippersnapper_uart_UartPacketFormat_MIN, 0, 0, 0} +#define wippersnapper_uart_UartB2D_init_zero {0, {wippersnapper_uart_UartAdd_init_zero}} +#define wippersnapper_uart_UartD2B_init_zero {0, {wippersnapper_uart_UartAdded_init_zero}} +#define wippersnapper_uart_UartSerialConfig_init_zero {"", "", {{NULL}, NULL}, 0, 0, _wippersnapper_uart_UartPacketFormat_MIN, 0, 0, 0} #define wippersnapper_uart_GenericUartInputConfig_init_zero {{{NULL}, NULL}, _wippersnapper_uart_GenericDeviceLineEnding_MIN, 0, 0, {_wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN}} #define wippersnapper_uart_TrinamicDynamixelConfig_init_zero {0} #define wippersnapper_uart_PM25AQIConfig_init_zero {0, 0, 0, {_wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN, _wippersnapper_sensor_SensorType_MIN}} @@ -264,20 +293,21 @@ extern "C" { /* Field tags (for use in manual encoding/decoding) */ #define wippersnapper_uart_UartSerialConfig_pin_rx_tag 1 #define wippersnapper_uart_UartSerialConfig_pin_tx_tag 2 -#define wippersnapper_uart_UartSerialConfig_uart_nbr_tag 3 -#define wippersnapper_uart_UartSerialConfig_baud_rate_tag 4 -#define wippersnapper_uart_UartSerialConfig_format_tag 5 -#define wippersnapper_uart_UartSerialConfig_timeout_tag 6 -#define wippersnapper_uart_UartSerialConfig_use_sw_serial_tag 7 -#define wippersnapper_uart_UartSerialConfig_sw_serial_invert_tag 8 +#define wippersnapper_uart_UartSerialConfig_device_name_tag 3 +#define wippersnapper_uart_UartSerialConfig_uart_nbr_tag 4 +#define wippersnapper_uart_UartSerialConfig_baud_rate_tag 5 +#define wippersnapper_uart_UartSerialConfig_format_tag 6 +#define wippersnapper_uart_UartSerialConfig_timeout_tag 7 +#define wippersnapper_uart_UartSerialConfig_use_sw_serial_tag 8 +#define wippersnapper_uart_UartSerialConfig_sw_serial_invert_tag 9 #define wippersnapper_uart_GenericUartInputConfig_name_tag 1 #define wippersnapper_uart_GenericUartInputConfig_line_ending_tag 2 #define wippersnapper_uart_GenericUartInputConfig_period_tag 3 -#define wippersnapper_uart_GenericUartInputConfig_i2c_device_sensor_types_tag 4 +#define wippersnapper_uart_GenericUartInputConfig_sensor_types_tag 4 #define wippersnapper_uart_TrinamicDynamixelConfig_device_id_tag 1 #define wippersnapper_uart_PM25AQIConfig_is_pm1006_tag 1 #define wippersnapper_uart_PM25AQIConfig_period_tag 2 -#define wippersnapper_uart_PM25AQIConfig_i2c_device_sensor_types_tag 3 +#define wippersnapper_uart_PM25AQIConfig_sensor_types_tag 3 #define wippersnapper_uart_UartDeviceConfig_device_type_tag 1 #define wippersnapper_uart_UartDeviceConfig_device_id_tag 2 #define wippersnapper_uart_UartDeviceConfig_generic_uart_input_tag 3 @@ -298,6 +328,9 @@ extern "C" { #define wippersnapper_uart_UartWrite_device_id_tag 3 #define wippersnapper_uart_UartWrite_bytes_data_tag 4 #define wippersnapper_uart_UartWrite_text_data_tag 5 +#define wippersnapper_uart_UartB2D_uart_add_tag 10 +#define wippersnapper_uart_UartB2D_uart_remove_tag 11 +#define wippersnapper_uart_UartB2D_uart_write_tag 12 #define wippersnapper_uart_UartWritten_uart_nbr_tag 1 #define wippersnapper_uart_UartWritten_type_tag 2 #define wippersnapper_uart_UartWritten_device_id_tag 3 @@ -306,25 +339,49 @@ extern "C" { #define wippersnapper_uart_UartInputEvent_type_tag 2 #define wippersnapper_uart_UartInputEvent_device_id_tag 3 #define wippersnapper_uart_UartInputEvent_events_tag 4 +#define wippersnapper_uart_UartD2B_uart_added_tag 10 +#define wippersnapper_uart_UartD2B_uart_written_tag 11 +#define wippersnapper_uart_UartD2B_uart_input_event_tag 12 /* Struct field encoding specification for nanopb */ +#define wippersnapper_uart_UartB2D_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart_add,payload.uart_add), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart_remove,payload.uart_remove), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart_write,payload.uart_write), 12) +#define wippersnapper_uart_UartB2D_CALLBACK NULL +#define wippersnapper_uart_UartB2D_DEFAULT NULL +#define wippersnapper_uart_UartB2D_payload_uart_add_MSGTYPE wippersnapper_uart_UartAdd +#define wippersnapper_uart_UartB2D_payload_uart_remove_MSGTYPE wippersnapper_uart_UartRemove +#define wippersnapper_uart_UartB2D_payload_uart_write_MSGTYPE wippersnapper_uart_UartWrite + +#define wippersnapper_uart_UartD2B_FIELDLIST(X, a) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart_added,payload.uart_added), 10) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart_written,payload.uart_written), 11) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,uart_input_event,payload.uart_input_event), 12) +#define wippersnapper_uart_UartD2B_CALLBACK NULL +#define wippersnapper_uart_UartD2B_DEFAULT NULL +#define wippersnapper_uart_UartD2B_payload_uart_added_MSGTYPE wippersnapper_uart_UartAdded +#define wippersnapper_uart_UartD2B_payload_uart_written_MSGTYPE wippersnapper_uart_UartWritten +#define wippersnapper_uart_UartD2B_payload_uart_input_event_MSGTYPE wippersnapper_uart_UartInputEvent + #define wippersnapper_uart_UartSerialConfig_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, STRING, pin_rx, 1) \ X(a, STATIC, SINGULAR, STRING, pin_tx, 2) \ -X(a, STATIC, SINGULAR, UINT32, uart_nbr, 3) \ -X(a, STATIC, SINGULAR, UINT32, baud_rate, 4) \ -X(a, STATIC, SINGULAR, UENUM, format, 5) \ -X(a, STATIC, SINGULAR, FLOAT, timeout, 6) \ -X(a, STATIC, SINGULAR, BOOL, use_sw_serial, 7) \ -X(a, STATIC, SINGULAR, BOOL, sw_serial_invert, 8) -#define wippersnapper_uart_UartSerialConfig_CALLBACK NULL +X(a, CALLBACK, SINGULAR, STRING, device_name, 3) \ +X(a, STATIC, SINGULAR, UINT32, uart_nbr, 4) \ +X(a, STATIC, SINGULAR, UINT32, baud_rate, 5) \ +X(a, STATIC, SINGULAR, UENUM, format, 6) \ +X(a, STATIC, SINGULAR, FLOAT, timeout, 7) \ +X(a, STATIC, SINGULAR, BOOL, use_sw_serial, 8) \ +X(a, STATIC, SINGULAR, BOOL, sw_serial_invert, 9) +#define wippersnapper_uart_UartSerialConfig_CALLBACK pb_default_field_callback #define wippersnapper_uart_UartSerialConfig_DEFAULT NULL #define wippersnapper_uart_GenericUartInputConfig_FIELDLIST(X, a) \ X(a, CALLBACK, SINGULAR, STRING, name, 1) \ X(a, STATIC, SINGULAR, UENUM, line_ending, 2) \ X(a, STATIC, SINGULAR, INT32, period, 3) \ -X(a, STATIC, REPEATED, UENUM, i2c_device_sensor_types, 4) +X(a, STATIC, REPEATED, UENUM, sensor_types, 4) #define wippersnapper_uart_GenericUartInputConfig_CALLBACK pb_default_field_callback #define wippersnapper_uart_GenericUartInputConfig_DEFAULT NULL @@ -336,7 +393,7 @@ X(a, STATIC, SINGULAR, UINT32, device_id, 1) #define wippersnapper_uart_PM25AQIConfig_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, BOOL, is_pm1006, 1) \ X(a, STATIC, SINGULAR, INT32, period, 2) \ -X(a, STATIC, REPEATED, UENUM, i2c_device_sensor_types, 3) +X(a, STATIC, REPEATED, UENUM, sensor_types, 3) #define wippersnapper_uart_PM25AQIConfig_CALLBACK NULL #define wippersnapper_uart_PM25AQIConfig_DEFAULT NULL @@ -403,6 +460,8 @@ X(a, STATIC, REPEATED, MESSAGE, events, 4) #define wippersnapper_uart_UartInputEvent_DEFAULT NULL #define wippersnapper_uart_UartInputEvent_events_MSGTYPE wippersnapper_sensor_SensorEvent +extern const pb_msgdesc_t wippersnapper_uart_UartB2D_msg; +extern const pb_msgdesc_t wippersnapper_uart_UartD2B_msg; extern const pb_msgdesc_t wippersnapper_uart_UartSerialConfig_msg; extern const pb_msgdesc_t wippersnapper_uart_GenericUartInputConfig_msg; extern const pb_msgdesc_t wippersnapper_uart_TrinamicDynamixelConfig_msg; @@ -416,6 +475,8 @@ extern const pb_msgdesc_t wippersnapper_uart_UartWritten_msg; extern const pb_msgdesc_t wippersnapper_uart_UartInputEvent_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ +#define wippersnapper_uart_UartB2D_fields &wippersnapper_uart_UartB2D_msg +#define wippersnapper_uart_UartD2B_fields &wippersnapper_uart_UartD2B_msg #define wippersnapper_uart_UartSerialConfig_fields &wippersnapper_uart_UartSerialConfig_msg #define wippersnapper_uart_GenericUartInputConfig_fields &wippersnapper_uart_GenericUartInputConfig_msg #define wippersnapper_uart_TrinamicDynamixelConfig_fields &wippersnapper_uart_TrinamicDynamixelConfig_msg @@ -429,20 +490,25 @@ extern const pb_msgdesc_t wippersnapper_uart_UartInputEvent_msg; #define wippersnapper_uart_UartInputEvent_fields &wippersnapper_uart_UartInputEvent_msg /* Maximum encoded size of messages (where known) */ +#if defined(wippersnapper_sensor_SensorEvent_size) +union wippersnapper_uart_UartD2B_payload_size_union {char f12[(121 + 15*wippersnapper_sensor_SensorEvent_size)]; char f0[49];}; +#endif +/* wippersnapper_uart_UartB2D_size depends on runtime parameters */ +/* wippersnapper_uart_UartSerialConfig_size depends on runtime parameters */ /* wippersnapper_uart_GenericUartInputConfig_size depends on runtime parameters */ /* wippersnapper_uart_UartDeviceConfig_size depends on runtime parameters */ /* wippersnapper_uart_UartAdd_size depends on runtime parameters */ /* wippersnapper_uart_UartWrite_size depends on runtime parameters */ +#if defined(wippersnapper_sensor_SensorEvent_size) +#define WIPPERSNAPPER_UART_UART_PB_H_MAX_SIZE wippersnapper_uart_UartInputEvent_size +#define wippersnapper_uart_UartD2B_size (0 + sizeof(union wippersnapper_uart_UartD2B_payload_size_union)) +#define wippersnapper_uart_UartInputEvent_size (115 + 15*wippersnapper_sensor_SensorEvent_size) +#endif #define wippersnapper_uart_PM25AQIConfig_size 43 #define wippersnapper_uart_TrinamicDynamixelConfig_size 6 #define wippersnapper_uart_UartAdded_size 43 #define wippersnapper_uart_UartRemove_size 41 -#define wippersnapper_uart_UartSerialConfig_size 57 #define wippersnapper_uart_UartWritten_size 47 -#if defined(wippersnapper_sensor_SensorEvent_size) -#define WIPPERSNAPPER_UART_UART_PB_H_MAX_SIZE wippersnapper_uart_UartInputEvent_size -#define wippersnapper_uart_UartInputEvent_size (115 + 15*wippersnapper_sensor_SensorEvent_size) -#endif #ifdef __cplusplus } /* extern "C" */ From 385018228776d4ac42bcb03e0698ff3b7411610e Mon Sep 17 00:00:00 2001 From: brentru Date: Wed, 12 Nov 2025 16:17:48 -0500 Subject: [PATCH 2/7] Add new protos, start removing all callback to old protos --- src/Wippersnapper_V2.cpp | 12 ++--- src/Wippersnapper_demo.ino.cpp | 21 ++++++++ src/components/analogIO/controller.cpp | 4 +- src/components/digitalIO/controller.cpp | 4 +- src/components/ds18x20/controller.cpp | 8 +-- src/components/gps/controller.cpp | 4 +- src/components/i2c/controller.cpp | 4 +- src/components/pixels/controller.cpp | 4 +- src/components/pwm/controller.cpp | 37 ++++++------- src/components/pwm/model.cpp | 26 ++++----- src/components/pwm/model.h | 10 ++-- src/components/servo/controller.cpp | 4 +- src/components/uart/controller.cpp | 12 ++--- src/protos/analogio.pb.c | 2 +- src/protos/analogio.pb.h | 2 +- src/protos/checkin.pb.c | 6 +-- src/protos/checkin.pb.h | 72 +++++++++++++------------ src/protos/digitalio.pb.c | 2 +- src/protos/digitalio.pb.h | 2 +- src/protos/ds18x20.pb.c | 2 +- src/protos/ds18x20.pb.h | 2 +- src/protos/error.pb.c | 2 +- src/protos/error.pb.h | 2 +- src/protos/gps.pb.c | 5 +- src/protos/gps.pb.h | 20 +------ src/protos/i2c.pb.c | 2 +- src/protos/i2c.pb.h | 2 +- src/protos/i2c_output.pb.c | 2 +- src/protos/i2c_output.pb.h | 2 +- src/protos/pixels.pb.c | 2 +- src/protos/pixels.pb.h | 2 +- src/protos/pwm.pb.c | 2 +- src/protos/pwm.pb.h | 2 +- src/protos/sensor.pb.c | 2 +- src/protos/sensor.pb.h | 2 +- src/protos/servo.pb.c | 2 +- src/protos/servo.pb.h | 2 +- src/protos/signal.pb.c | 4 +- src/protos/signal.pb.h | 15 ++++-- src/protos/uart.pb.c | 2 +- src/protos/uart.pb.h | 2 +- src/provisioning/sdcard/ws_sdcard.cpp | 4 +- 42 files changed, 165 insertions(+), 155 deletions(-) create mode 100644 src/Wippersnapper_demo.ino.cpp diff --git a/src/Wippersnapper_V2.cpp b/src/Wippersnapper_V2.cpp index cf953a8d3..d94ca37a2 100644 --- a/src/Wippersnapper_V2.cpp +++ b/src/Wippersnapper_V2.cpp @@ -303,7 +303,7 @@ bool handleCheckinResponse(pb_istream_t *stream) { bool cbDecodeBrokerToDevice(pb_istream_t *stream, const pb_field_t *field, void **arg) { (void)arg; // marking unused parameters to avoid compiler warning - +/* switch (field->tag) { case wippersnapper_signal_BrokerToDevice_checkin_response_tag: WS_DEBUG_PRINTLN("-> Checkin Response Message Type"); @@ -460,7 +460,7 @@ bool cbDecodeBrokerToDevice(pb_istream_t *stream, const pb_field_t *field, default: WS_DEBUG_PRINTLN("ERROR: BrokerToDevice message type not found!"); return false; - } + } */ // once this is returned, pb_dec_submessage() // decodes the submessage contents. return true; @@ -965,7 +965,7 @@ bool Wippersnapper_V2::PublishSignal(pb_size_t which_payload, void *payload) { size_t szMessageBuf; wippersnapper_signal_DeviceToBroker MsgSignal = wippersnapper_signal_DeviceToBroker_init_default; - +/* // Fill generic signal payload with the payload from the args. WS_DEBUG_PRINT("Signal Payload Type: "); switch (which_payload) { @@ -1043,7 +1043,7 @@ bool Wippersnapper_V2::PublishSignal(pb_size_t which_payload, void *payload) { default: WS_DEBUG_PRINTLN("ERROR: Invalid signal payload type, bailing out!"); return false; - } + } */ // Get the encoded size of the signal message if (!pb_get_encoded_size(&szMessageBuf, @@ -1118,9 +1118,9 @@ bool Wippersnapper_V2::CreateCheckinRequest() { WS_DEBUG_PRINTLN("Encoded!"); WS_DEBUG_PRINT("Publishing Checkin Request..."); - if (!PublishSignal(wippersnapper_signal_DeviceToBroker_checkin_request_tag, +/* if (!PublishSignal(wippersnapper_signal_DeviceToBroker_checkin_request_tag, WsV2.CheckInModel->getCheckinRequest())) - return false; + return false; */ WS_DEBUG_PRINTLN("Published!"); return true; diff --git a/src/Wippersnapper_demo.ino.cpp b/src/Wippersnapper_demo.ino.cpp new file mode 100644 index 000000000..d401831f5 --- /dev/null +++ b/src/Wippersnapper_demo.ino.cpp @@ -0,0 +1,21 @@ +# 1 "/var/folders/ff/dmzflvf52tq9kzvt6g8jglxw0000gn/T/tmpvab_6n0x" +#include +# 1 "/Users/brentrubell/Documents/Arduino/libraries/Adafruit_Wippersnapper_Arduino/src/Wippersnapper_demo.ino" +# 11 "/Users/brentrubell/Documents/Arduino/libraries/Adafruit_Wippersnapper_Arduino/src/Wippersnapper_demo.ino" +#include "ws_adapters.h" +ws_adapter_wifi wipper; + + +#define WS_DEBUG +void setup(); +void loop(); +#line 17 "/Users/brentrubell/Documents/Arduino/libraries/Adafruit_Wippersnapper_Arduino/src/Wippersnapper_demo.ino" +void setup() { + Serial.begin(115200); + while (!Serial) + delay(10); + wipper.provision(); + wipper.connect(); +} + +void loop() { wipper.run(); } \ No newline at end of file diff --git a/src/components/analogIO/controller.cpp b/src/components/analogIO/controller.cpp index 366819d8c..b4ac22ccd 100644 --- a/src/components/analogIO/controller.cpp +++ b/src/components/analogIO/controller.cpp @@ -170,13 +170,13 @@ bool AnalogIOController::EncodePublishPinEvent( // Publish the AnalogIO message to the broker WS_DEBUG_PRINTLN("Publishing AnalogIOEvent message to broker..."); - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_analogio_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; diff --git a/src/components/digitalIO/controller.cpp b/src/components/digitalIO/controller.cpp index 810b5c387..300f43acb 100644 --- a/src/components/digitalIO/controller.cpp +++ b/src/components/digitalIO/controller.cpp @@ -295,13 +295,13 @@ bool DigitalIOController::EncodePublishPinEvent(uint8_t pin_name, } // Publish the DigitalIOEvent message to the broker - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_digitalio_event_tag, _dio_model->GetDigitalIOEventMsg())) { WS_DEBUG_PRINTLN("[digitalio] ERROR: Unable to publish event message, " "moving onto the next pin!"); return false; - } + } */ WS_DEBUG_PRINTLN("[digitalio] Published DigitalIOEvent to broker!") } else { // let's log the event to the SD card diff --git a/src/components/ds18x20/controller.cpp b/src/components/ds18x20/controller.cpp index 49581429a..3292499c6 100644 --- a/src/components/ds18x20/controller.cpp +++ b/src/components/ds18x20/controller.cpp @@ -140,13 +140,13 @@ bool DS18X20Controller::Handle_Ds18x20Add(pb_istream_t *stream) { return false; } - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_ds18x20_added_tag, _DS18X20_model->GetDS18x20AddedMsg())) { WS_DEBUG_PRINTLN( "ERROR | DS18x20: Unable to publish Ds18x20Added message!"); return false; - } + } */ } return true; @@ -260,13 +260,13 @@ void DS18X20Controller::update() { } // Publish the Ds18x20Event message to the broker WS_DEBUG_PRINT("DS18x20: Publishing event to broker..."); - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_ds18x20_event_tag, _DS18X20_model->GetDS18x20EventMsg())) { WS_DEBUG_PRINTLN( "ERROR | DS18x20: Failed to publish Ds18x20Event message"); continue; - } + } */ WS_DEBUG_PRINTLN("Published!"); } else { if (!WsV2._sdCardV2->LogDS18xSensorEventToSD( diff --git a/src/components/gps/controller.cpp b/src/components/gps/controller.cpp index 7aa9981c8..deac40d8b 100644 --- a/src/components/gps/controller.cpp +++ b/src/components/gps/controller.cpp @@ -161,13 +161,13 @@ void GPSController::update() { WS_DEBUG_PRINTLN("[gps] ERROR: Failed to encode GPSEvent!"); } else { // Publish the GPSEvent to IO - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_gps_event_tag, _gps_model->GetGPSEvent())) { WS_DEBUG_PRINTLN("[gps] ERROR: Failed to publish GPSEvent!"); } else { WS_DEBUG_PRINTLN("...ok!"); - } + } */ } drv->SetPollPeriodPrv(cur_time); } diff --git a/src/components/i2c/controller.cpp b/src/components/i2c/controller.cpp index 4637e8722..be45ae0c0 100644 --- a/src/components/i2c/controller.cpp +++ b/src/components/i2c/controller.cpp @@ -552,13 +552,13 @@ bool I2cController::PublishI2cDeviceAddedorReplaced( "[i2c] ERROR: Unable to encode I2cDeviceAddedorReplaced message!"); return false; } - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_i2c_device_added_replaced_tag, _i2c_model->GetMsgI2cDeviceAddedOrReplaced())) { WS_DEBUG_PRINTLN("[i2c] ERROR: Unable to publish I2cDeviceAddedorReplaced " "message to IO!"); return false; - } + } */ return true; } diff --git a/src/components/pixels/controller.cpp b/src/components/pixels/controller.cpp index eeed20a1c..35645381c 100644 --- a/src/components/pixels/controller.cpp +++ b/src/components/pixels/controller.cpp @@ -67,11 +67,11 @@ bool PixelsController::Handle_Pixels_Add(pb_istream_t *stream) { WS_DEBUG_PRINTLN("[pixels]: Failed to encode PixelsAdded message!"); return false; } - if (!WsV2.PublishSignal(wippersnapper_signal_DeviceToBroker_pixels_added_tag, +/* if (!WsV2.PublishSignal(wippersnapper_signal_DeviceToBroker_pixels_added_tag, _pixels_model->GetPixelsAddedMsg())) { WS_DEBUG_PRINTLN("[pixels]: Unable to publish PixelsAdded message!"); return false; - } + } */ return true; } diff --git a/src/components/pwm/controller.cpp b/src/components/pwm/controller.cpp index 4b68c37f6..70053ee51 100644 --- a/src/components/pwm/controller.cpp +++ b/src/components/pwm/controller.cpp @@ -58,11 +58,11 @@ bool PWMController::Handle_PWM_Add(pb_istream_t *stream) { WS_DEBUG_PRINTLN("[pwm]: Failed to encode PWMAdded message!"); return false; } - if (!WsV2.PublishSignal(wippersnapper_signal_DeviceToBroker_pwm_added_tag, +/* if (!WsV2.PublishSignal(wippersnapper_signal_DeviceToBroker_pwm_added_tag, _pwm_model->GetPWMAddedMsg())) { WS_DEBUG_PRINTLN("[PWM]: Unable to publish PWMAdded message!"); return false; - } + } */ WS_DEBUG_PRINTLN("...attached!"); return true; } @@ -136,25 +136,25 @@ bool PWMController::Handle_PWM_Write_DutyCycle(pb_istream_t *stream) { return false; } - wippersnapper_pwm_PWMWriteDutyCycle msg_write_duty_cycle = +/* wippersnapper_pwm_PWMWriteDutyCycle msg_write_duty_cycle = *_pwm_model->GetPWMWriteDutyCycleMsg(); - uint8_t pin = atoi(msg_write_duty_cycle.pin + 1); - int pin_idx = GetPWMHardwareIdx(pin); - if (pin_idx == -1) { + uint8_t pin = atoi(msg_write_duty_cycle.pin + 1); */ + /* int pin_idx = GetPWMHardwareIdx(pin); */ +/* if (pin_idx == -1) { WS_DEBUG_PRINTLN("[pwm] Error: pin not found!"); return false; - } + } */ // Write the duty cycle to the pin - if (!_pwm_hardware[pin_idx]->WriteDutyCycle( +/* if (!_pwm_hardware[pin_idx]->WriteDutyCycle( msg_write_duty_cycle.duty_cycle)) { WS_DEBUG_PRINTLN("[pwm] Error: Failed to write duty cycle!"); return false; - } + } */ WS_DEBUG_PRINTLN("[pwm] Wrote duty cycle: "); - WS_DEBUG_PRINT(msg_write_duty_cycle.duty_cycle); + /* WS_DEBUG_PRINT(msg_write_duty_cycle.duty_cycle); */ WS_DEBUG_PRINTLN(" to pin: "); - WS_DEBUG_PRINT(msg_write_duty_cycle.pin); + /* WS_DEBUG_PRINT(msg_write_duty_cycle.pin); */ return true; } @@ -169,23 +169,24 @@ bool PWMController::Handle_PWM_Write_Frequency(pb_istream_t *stream) { "[pwm] Error: Failed to decode PWMWriteFrequency message!"); return false; } - wippersnapper_pwm_PWMWriteFrequency msg_write_frequency = +/* wippersnapper_pwm_PWMWriteFrequency msg_write_frequency = *_pwm_model->GetPWMWriteFrequencyMsg(); - uint8_t pin = atoi(msg_write_frequency.pin + 1); - int pin_idx = GetPWMHardwareIdx(pin); + uint8_t pin = atoi(msg_write_frequency.pin + 1); */ + //int pin_idx; + pin_idx = GetPWMHardwareIdx(pin); if (pin_idx == -1) { WS_DEBUG_PRINTLN("[pwm] Error: pin not found!"); return false; } - if (_pwm_hardware[pin_idx]->WriteTone(msg_write_frequency.frequency) != +/* if (_pwm_hardware[pin_idx]->WriteTone(msg_write_frequency.frequency) != msg_write_frequency.frequency) { WS_DEBUG_PRINTLN("[pwm] Error: Failed to write frequency!"); return false; - } + } */ WS_DEBUG_PRINTLN("[pwm] Wrote frequency: "); - WS_DEBUG_PRINT(msg_write_frequency.frequency); + /* WS_DEBUG_PRINT(msg_write_frequency.frequency); */ WS_DEBUG_PRINTLN(" to pin: "); - WS_DEBUG_PRINT(msg_write_frequency.pin); + /* WS_DEBUG_PRINT(msg_write_frequency.pin); */ return true; } \ No newline at end of file diff --git a/src/components/pwm/model.cpp b/src/components/pwm/model.cpp index f8b7249d5..bad6c3909 100644 --- a/src/components/pwm/model.cpp +++ b/src/components/pwm/model.cpp @@ -21,8 +21,8 @@ PWMModel::PWMModel() { memset(&_msg_pwm_add, 0, sizeof(_msg_pwm_add)); memset(&_msg_pwm_added, 0, sizeof(_msg_pwm_added)); memset(&_msg_pwm_remove, 0, sizeof(_msg_pwm_remove)); - memset(&_msg_pwm_write_duty_cycle, 0, sizeof(_msg_pwm_write_duty_cycle)); - memset(&_msg_pwm_write_frequency, 0, sizeof(_msg_pwm_write_frequency)); + /* memset(&_msg_pwm_write_duty_cycle, 0, sizeof(_msg_pwm_write_duty_cycle)); */ + /* memset(&_msg_pwm_write_frequency, 0, sizeof(_msg_pwm_write_frequency)); */ } /*! @@ -32,8 +32,8 @@ PWMModel::~PWMModel() { memset(&_msg_pwm_add, 0, sizeof(_msg_pwm_add)); memset(&_msg_pwm_added, 0, sizeof(_msg_pwm_added)); memset(&_msg_pwm_remove, 0, sizeof(_msg_pwm_remove)); - memset(&_msg_pwm_write_duty_cycle, 0, sizeof(_msg_pwm_write_duty_cycle)); - memset(&_msg_pwm_write_frequency, 0, sizeof(_msg_pwm_write_frequency)); + /* memset(&_msg_pwm_write_duty_cycle, 0, sizeof(_msg_pwm_write_duty_cycle)); */ + /* memset(&_msg_pwm_write_frequency, 0, sizeof(_msg_pwm_write_frequency)); */ } /*! @@ -109,18 +109,19 @@ wippersnapper_pwm_PWMRemove *PWMModel::GetPWMRemoveMsg() { @return true if successful, false otherwise. */ bool PWMModel::DecodePWMWriteDutyCycle(pb_istream_t *stream) { - memset(&_msg_pwm_write_duty_cycle, 0, sizeof(_msg_pwm_write_duty_cycle)); +/* memset(&_msg_pwm_write_duty_cycle, 0, sizeof(_msg_pwm_write_duty_cycle)); return pb_decode(stream, wippersnapper_pwm_PWMWriteDutyCycle_fields, - &_msg_pwm_write_duty_cycle); + &_msg_pwm_write_duty_cycle); */ + return false; // TODO: Remove once re-implemented } /*! @brief Returns a pointer to the PWMWriteDutyCycle message. @return Pointer to the PWMWriteDutyCycle message. */ -wippersnapper_pwm_PWMWriteDutyCycle *PWMModel::GetPWMWriteDutyCycleMsg() { +/* wippersnapper_pwm_PWMWriteDutyCycle *PWMModel::GetPWMWriteDutyCycleMsg() { return &_msg_pwm_write_duty_cycle; -} +} */ /*! @brief Decodes a PWMWriteFrequency message from an input stream. @@ -128,15 +129,16 @@ wippersnapper_pwm_PWMWriteDutyCycle *PWMModel::GetPWMWriteDutyCycleMsg() { @return true if successful, false otherwise. */ bool PWMModel::DecodePWMWriteFrequency(pb_istream_t *stream) { - memset(&_msg_pwm_write_frequency, 0, sizeof(_msg_pwm_write_frequency)); +/* memset(&_msg_pwm_write_frequency, 0, sizeof(_msg_pwm_write_frequency)); return pb_decode(stream, wippersnapper_pwm_PWMWriteFrequency_fields, - &_msg_pwm_write_frequency); + &_msg_pwm_write_frequency); */ + return false;// TODO: Remove once re-implemented } /*! @brief Returns a pointer to the PWMWriteFrequency message. @return Pointer to the PWMWriteFrequency message. */ -wippersnapper_pwm_PWMWriteFrequency *PWMModel::GetPWMWriteFrequencyMsg() { +/* wippersnapper_pwm_PWMWriteFrequency *PWMModel::GetPWMWriteFrequencyMsg() { return &_msg_pwm_write_frequency; -} +} */ diff --git a/src/components/pwm/model.h b/src/components/pwm/model.h index 3f951d21c..206490652 100644 --- a/src/components/pwm/model.h +++ b/src/components/pwm/model.h @@ -31,17 +31,15 @@ class PWMModel { bool DecodePWMRemove(pb_istream_t *stream); wippersnapper_pwm_PWMRemove *GetPWMRemoveMsg(); bool DecodePWMWriteDutyCycle(pb_istream_t *stream); - wippersnapper_pwm_PWMWriteDutyCycle *GetPWMWriteDutyCycleMsg(); + /* wippersnapper_pwm_PWMWriteDutyCycle *GetPWMWriteDutyCycleMsg(); */ bool DecodePWMWriteFrequency(pb_istream_t *stream); - wippersnapper_pwm_PWMWriteFrequency *GetPWMWriteFrequencyMsg(); + /* wippersnapper_pwm_PWMWriteFrequency *GetPWMWriteFrequencyMsg(); */ private: wippersnapper_pwm_PWMAdd _msg_pwm_add; ///< PWMAdd message object wippersnapper_pwm_PWMAdded _msg_pwm_added; ///< PWMAdded message object wippersnapper_pwm_PWMRemove _msg_pwm_remove; ///< PWMRemove message object - wippersnapper_pwm_PWMWriteDutyCycle - _msg_pwm_write_duty_cycle; ///< PWMWriteDutyCycle message object - wippersnapper_pwm_PWMWriteFrequency - _msg_pwm_write_frequency; ///< PWMWriteFrequency message object + /* wippersnapper_pwm_PWMWriteDutyCycle _msg_pwm_write_duty_cycle; ///< PWMWriteDutyCycle message object + wippersnapper_pwm_PWMWriteFrequency _msg_pwm_write_frequency; ///< PWMWriteFrequency message object */ }; #endif // WS_PWM_MODEL_H \ No newline at end of file diff --git a/src/components/servo/controller.cpp b/src/components/servo/controller.cpp index 33caec5c7..bc9c2b6ec 100644 --- a/src/components/servo/controller.cpp +++ b/src/components/servo/controller.cpp @@ -52,11 +52,11 @@ bool ServoController::PublishServoAddedMsg( const char *servo_pin, bool did_attach, wippersnapper_servo_ServoAdd *msg_add) { _servo_model->EncodeServoAdded(msg_add->servo_pin, did_attach); - if (!WsV2.PublishSignal(wippersnapper_signal_DeviceToBroker_servo_added_tag, +/* if (!WsV2.PublishSignal(wippersnapper_signal_DeviceToBroker_servo_added_tag, _servo_model->GetServoAddedMsg())) { WS_DEBUG_PRINTLN("[servo] Error: Failed publishing a ServoAdded message!"); return false; - } + } */ return true; } diff --git a/src/components/uart/controller.cpp b/src/components/uart/controller.cpp index 371e2fbaf..378ea7bc2 100644 --- a/src/components/uart/controller.cpp +++ b/src/components/uart/controller.cpp @@ -87,9 +87,9 @@ bool UARTController::Handle_UartAdd(pb_istream_t *stream) { uart_driver = new drvUartUs100(uart_hardware->GetHardwareSerial(), cfg_device.device_id, cfg_serial.uart_nbr); uart_driver->ConfigureDriver(cfg_device); - uart_driver->EnableSensorEvents( +/* uart_driver->EnableSensorEvents( cfg_device.config.generic_uart_input.i2c_device_sensor_types, - cfg_device.config.generic_uart_input.i2c_device_sensor_types_count); + cfg_device.config.generic_uart_input.i2c_device_sensor_types_count); */ uart_driver->SetSensorPeriod(cfg_device.config.generic_uart_input.period); WS_DEBUG_PRINT("added!"); } else { @@ -121,9 +121,9 @@ bool UARTController::Handle_UartAdd(pb_istream_t *stream) { uart_driver = new drvUartPm25(uart_hardware->GetHardwareSerial(), cfg_device.device_id, cfg_serial.uart_nbr); uart_driver->ConfigureDriver(cfg_device); - uart_driver->EnableSensorEvents( +/* uart_driver->EnableSensorEvents( cfg_device.config.pm25aqi.i2c_device_sensor_types, - cfg_device.config.pm25aqi.i2c_device_sensor_types_count); + cfg_device.config.pm25aqi.i2c_device_sensor_types_count); */ uart_driver->SetSensorPeriod(cfg_device.config.pm25aqi.period); WS_DEBUG_PRINT("added!"); break; @@ -286,12 +286,12 @@ void UARTController::update() { } */ } else { // In online mode, publish to Adafruit IO - if (!WsV2.PublishSignal( +/* if (!WsV2.PublishSignal( wippersnapper_signal_DeviceToBroker_uart_input_event_tag, _uart_model->GetUartInputEventMsg())) { WS_DEBUG_PRINTLN( "[uart] ERROR: Unable to publish UartInputEvent to IO!"); - } + } */ } } else { WS_DEBUG_PRINTLN( diff --git a/src/protos/analogio.pb.c b/src/protos/analogio.pb.c index e62a1bb6f..c51df3909 100644 --- a/src/protos/analogio.pb.c +++ b/src/protos/analogio.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "analogio.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/analogio.pb.h b/src/protos/analogio.pb.h index 26bb2f69e..e6fb4a01e 100644 --- a/src/protos/analogio.pb.h +++ b/src/protos/analogio.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_ANALOGIO_ANALOGIO_PB_H_INCLUDED #define PB_WIPPERSNAPPER_ANALOGIO_ANALOGIO_PB_H_INCLUDED diff --git a/src/protos/checkin.pb.c b/src/protos/checkin.pb.c index 26731b2be..5ea9f511f 100644 --- a/src/protos/checkin.pb.c +++ b/src/protos/checkin.pb.c @@ -1,12 +1,12 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "checkin.pb.h" #if PB_PROTO_HEADER_VERSION != 40 #error Regenerate this file with the current version of nanopb generator. #endif -PB_BIND(wippersnapper_checkin_CheckinB2D, wippersnapper_checkin_CheckinB2D, AUTO) +PB_BIND(wippersnapper_checkin_CheckinB2D, wippersnapper_checkin_CheckinB2D, 4) PB_BIND(wippersnapper_checkin_CheckinD2B, wippersnapper_checkin_CheckinD2B, AUTO) @@ -15,7 +15,7 @@ PB_BIND(wippersnapper_checkin_CheckinD2B, wippersnapper_checkin_CheckinD2B, AUTO PB_BIND(wippersnapper_checkin_CheckinRequest, wippersnapper_checkin_CheckinRequest, AUTO) -PB_BIND(wippersnapper_checkin_CheckinResponse, wippersnapper_checkin_CheckinResponse, AUTO) +PB_BIND(wippersnapper_checkin_CheckinResponse, wippersnapper_checkin_CheckinResponse, 4) PB_BIND(wippersnapper_checkin_ComponentAdd, wippersnapper_checkin_ComponentAdd, 2) diff --git a/src/protos/checkin.pb.h b/src/protos/checkin.pb.h index 5ec7241e9..6eb178075 100644 --- a/src/protos/checkin.pb.h +++ b/src/protos/checkin.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_INCLUDED #define PB_WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_INCLUDED @@ -34,6 +34,22 @@ typedef struct _wippersnapper_checkin_CheckinRequest { char firmware_version[25]; /* * Identifies the client's firmware version. */ } wippersnapper_checkin_CheckinRequest; +/* * + Generic component add message, could contain any *Add message from component protos */ +typedef struct _wippersnapper_checkin_ComponentAdd { + pb_size_t which_payload; + union { + wippersnapper_digitalio_DigitalIOAdd digitalio; + wippersnapper_analogio_AnalogIOAdd analogio; + wippersnapper_servo_ServoAdd servo; + wippersnapper_pwm_PWMAdd pwm; + wippersnapper_pixels_PixelsAdd pixels; + wippersnapper_ds18x20_Ds18x20Add ds18x20; + wippersnapper_uart_UartAdd uart; + wippersnapper_i2c_I2cDeviceAddOrReplace i2c; + } payload; +} wippersnapper_checkin_ComponentAdd; + /* * CheckinResponse sends a broker response to the client's CheckinRequest. */ typedef struct _wippersnapper_checkin_CheckinResponse { @@ -41,7 +57,8 @@ typedef struct _wippersnapper_checkin_CheckinResponse { int32_t total_gpio_pins; /* * Specifies the number of GPIO pins on the device. */ int32_t total_analog_pins; /* * Specifies the number of analog pins on the device. */ float reference_voltage; /* * Specifies the hardware's default reference voltage. */ - pb_callback_t component_adds; /* * A list of components to set up and initialize during checkin */ + pb_size_t component_adds_count; + wippersnapper_checkin_ComponentAdd component_adds[32]; /* * A list of components to set up and initialize during checkin */ } wippersnapper_checkin_CheckinResponse; /* * @@ -53,22 +70,6 @@ typedef struct _wippersnapper_checkin_CheckinB2D { } payload; } wippersnapper_checkin_CheckinB2D; -/* * - Generic component add message, could contain any *Add message from component protos */ -typedef struct _wippersnapper_checkin_ComponentAdd { - pb_size_t which_payload; - union { - wippersnapper_digitalio_DigitalIOAdd digitalio; - wippersnapper_analogio_AnalogIOAdd analogio; - wippersnapper_servo_ServoAdd servo; - wippersnapper_pwm_PWMAdd pwm; - wippersnapper_pixels_PixelsAdd pixels; - wippersnapper_ds18x20_Ds18x20Add ds18x20; - wippersnapper_uart_UartAdd uart; - wippersnapper_i2c_I2cDeviceAddOrReplace i2c; - } payload; -} wippersnapper_checkin_ComponentAdd; - /* * Signal to the broker that the device has completed the checkin routine and is now operating normally */ @@ -108,25 +109,19 @@ extern "C" { #define wippersnapper_checkin_CheckinB2D_init_default {0, {wippersnapper_checkin_CheckinResponse_init_default}} #define wippersnapper_checkin_CheckinD2B_init_default {0, {wippersnapper_checkin_CheckinRequest_init_default}} #define wippersnapper_checkin_CheckinRequest_init_default {"", ""} -#define wippersnapper_checkin_CheckinResponse_init_default {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0, {{NULL}, NULL}} +#define wippersnapper_checkin_CheckinResponse_init_default {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0, 0, {wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default, wippersnapper_checkin_ComponentAdd_init_default}} #define wippersnapper_checkin_ComponentAdd_init_default {0, {wippersnapper_digitalio_DigitalIOAdd_init_default}} #define wippersnapper_checkin_CheckinComplete_init_default {0} #define wippersnapper_checkin_CheckinB2D_init_zero {0, {wippersnapper_checkin_CheckinResponse_init_zero}} #define wippersnapper_checkin_CheckinD2B_init_zero {0, {wippersnapper_checkin_CheckinRequest_init_zero}} #define wippersnapper_checkin_CheckinRequest_init_zero {"", ""} -#define wippersnapper_checkin_CheckinResponse_init_zero {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0, {{NULL}, NULL}} +#define wippersnapper_checkin_CheckinResponse_init_zero {_wippersnapper_checkin_CheckinResponse_Response_MIN, 0, 0, 0, 0, {wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero, wippersnapper_checkin_ComponentAdd_init_zero}} #define wippersnapper_checkin_ComponentAdd_init_zero {0, {wippersnapper_digitalio_DigitalIOAdd_init_zero}} #define wippersnapper_checkin_CheckinComplete_init_zero {0} /* Field tags (for use in manual encoding/decoding) */ #define wippersnapper_checkin_CheckinRequest_hardware_uid_tag 1 #define wippersnapper_checkin_CheckinRequest_firmware_version_tag 2 -#define wippersnapper_checkin_CheckinResponse_response_tag 1 -#define wippersnapper_checkin_CheckinResponse_total_gpio_pins_tag 2 -#define wippersnapper_checkin_CheckinResponse_total_analog_pins_tag 3 -#define wippersnapper_checkin_CheckinResponse_reference_voltage_tag 4 -#define wippersnapper_checkin_CheckinResponse_component_adds_tag 5 -#define wippersnapper_checkin_CheckinB2D_checkin_response_tag 10 #define wippersnapper_checkin_ComponentAdd_digitalio_tag 1 #define wippersnapper_checkin_ComponentAdd_analogio_tag 2 #define wippersnapper_checkin_ComponentAdd_servo_tag 3 @@ -135,6 +130,12 @@ extern "C" { #define wippersnapper_checkin_ComponentAdd_ds18x20_tag 6 #define wippersnapper_checkin_ComponentAdd_uart_tag 7 #define wippersnapper_checkin_ComponentAdd_i2c_tag 8 +#define wippersnapper_checkin_CheckinResponse_response_tag 1 +#define wippersnapper_checkin_CheckinResponse_total_gpio_pins_tag 2 +#define wippersnapper_checkin_CheckinResponse_total_analog_pins_tag 3 +#define wippersnapper_checkin_CheckinResponse_reference_voltage_tag 4 +#define wippersnapper_checkin_CheckinResponse_component_adds_tag 5 +#define wippersnapper_checkin_CheckinB2D_checkin_response_tag 10 #define wippersnapper_checkin_CheckinD2B_checkin_request_tag 1 #define wippersnapper_checkin_CheckinD2B_checkin_complete_tag 2 @@ -164,8 +165,8 @@ X(a, STATIC, SINGULAR, UENUM, response, 1) \ X(a, STATIC, SINGULAR, INT32, total_gpio_pins, 2) \ X(a, STATIC, SINGULAR, INT32, total_analog_pins, 3) \ X(a, STATIC, SINGULAR, FLOAT, reference_voltage, 4) \ -X(a, CALLBACK, REPEATED, MESSAGE, component_adds, 5) -#define wippersnapper_checkin_CheckinResponse_CALLBACK pb_default_field_callback +X(a, STATIC, REPEATED, MESSAGE, component_adds, 5) +#define wippersnapper_checkin_CheckinResponse_CALLBACK NULL #define wippersnapper_checkin_CheckinResponse_DEFAULT NULL #define wippersnapper_checkin_CheckinResponse_component_adds_MSGTYPE wippersnapper_checkin_ComponentAdd @@ -213,15 +214,18 @@ extern const pb_msgdesc_t wippersnapper_checkin_CheckinComplete_msg; #if defined(wippersnapper_uart_UartAdd_size) union wippersnapper_checkin_ComponentAdd_payload_size_union {char f7[(6 + wippersnapper_uart_UartAdd_size)]; char f0[1920];}; #endif -/* wippersnapper_checkin_CheckinB2D_size depends on runtime parameters */ -/* wippersnapper_checkin_CheckinResponse_size depends on runtime parameters */ -#define WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_MAX_SIZE wippersnapper_checkin_CheckinD2B_size -#define wippersnapper_checkin_CheckinComplete_size 0 -#define wippersnapper_checkin_CheckinD2B_size 93 -#define wippersnapper_checkin_CheckinRequest_size 91 #if defined(wippersnapper_uart_UartAdd_size) +union wippersnapper_checkin_ComponentAdd_payload_size_union {char f7[(6 + wippersnapper_uart_UartAdd_size)]; char f0[1920];}; +#endif +#if defined(wippersnapper_uart_UartAdd_size) +#define WIPPERSNAPPER_CHECKIN_CHECKIN_PB_H_MAX_SIZE wippersnapper_checkin_CheckinB2D_size +#define wippersnapper_checkin_CheckinB2D_size (227 + 32*sizeof(union wippersnapper_checkin_ComponentAdd_payload_size_union)) +#define wippersnapper_checkin_CheckinResponse_size (221 + 32*sizeof(union wippersnapper_checkin_ComponentAdd_payload_size_union)) #define wippersnapper_checkin_ComponentAdd_size (0 + sizeof(union wippersnapper_checkin_ComponentAdd_payload_size_union)) #endif +#define wippersnapper_checkin_CheckinComplete_size 0 +#define wippersnapper_checkin_CheckinD2B_size 93 +#define wippersnapper_checkin_CheckinRequest_size 91 #ifdef __cplusplus } /* extern "C" */ diff --git a/src/protos/digitalio.pb.c b/src/protos/digitalio.pb.c index 0961c05b5..cca3dab53 100644 --- a/src/protos/digitalio.pb.c +++ b/src/protos/digitalio.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "digitalio.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/digitalio.pb.h b/src/protos/digitalio.pb.h index a8aa4b5f4..4bec741ac 100644 --- a/src/protos/digitalio.pb.h +++ b/src/protos/digitalio.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_DIGITALIO_DIGITALIO_PB_H_INCLUDED #define PB_WIPPERSNAPPER_DIGITALIO_DIGITALIO_PB_H_INCLUDED diff --git a/src/protos/ds18x20.pb.c b/src/protos/ds18x20.pb.c index cbd4614db..b5a9b705b 100644 --- a/src/protos/ds18x20.pb.c +++ b/src/protos/ds18x20.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "ds18x20.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/ds18x20.pb.h b/src/protos/ds18x20.pb.h index b7aa64250..f28bbdcad 100644 --- a/src/protos/ds18x20.pb.h +++ b/src/protos/ds18x20.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_DS18X20_DS18X20_PB_H_INCLUDED #define PB_WIPPERSNAPPER_DS18X20_DS18X20_PB_H_INCLUDED diff --git a/src/protos/error.pb.c b/src/protos/error.pb.c index 431fe48ac..5eb76d30a 100644 --- a/src/protos/error.pb.c +++ b/src/protos/error.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "error.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/error.pb.h b/src/protos/error.pb.h index 3ed3fbefc..0a39529f1 100644 --- a/src/protos/error.pb.h +++ b/src/protos/error.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_ERROR_ERROR_PB_H_INCLUDED #define PB_WIPPERSNAPPER_ERROR_ERROR_PB_H_INCLUDED diff --git a/src/protos/gps.pb.c b/src/protos/gps.pb.c index 008198750..84aa66ed4 100644 --- a/src/protos/gps.pb.c +++ b/src/protos/gps.pb.c @@ -1,14 +1,11 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "gps.pb.h" #if PB_PROTO_HEADER_VERSION != 40 #error Regenerate this file with the current version of nanopb generator. #endif -PB_BIND(wippersnapper_gps_GPSB2D, wippersnapper_gps_GPSB2D, AUTO) - - PB_BIND(wippersnapper_gps_GPSD2B, wippersnapper_gps_GPSD2B, 2) diff --git a/src/protos/gps.pb.h b/src/protos/gps.pb.h index b08f88691..0933022ce 100644 --- a/src/protos/gps.pb.h +++ b/src/protos/gps.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_GPS_GPS_PB_H_INCLUDED #define PB_WIPPERSNAPPER_GPS_GPS_PB_H_INCLUDED @@ -10,14 +10,6 @@ #endif /* Struct definitions */ -/* * - BrokerToDevice message envelope */ -typedef struct _wippersnapper_gps_GPSB2D { /* oneof payload { - - } */ - char dummy_field; -} wippersnapper_gps_GPSB2D; - typedef PB_BYTES_ARRAY_T(128) wippersnapper_gps_GPSConfig_commands_ubxes_t; /* * GPSConfig represents a message containing configuration data to set up and configure a GPS. @@ -94,14 +86,12 @@ extern "C" { #endif /* Initializer values for message structs */ -#define wippersnapper_gps_GPSB2D_init_default {0} #define wippersnapper_gps_GPSD2B_init_default {0, {wippersnapper_gps_GPSEvent_init_default}} #define wippersnapper_gps_GPSConfig_init_default {0, {"", "", "", "", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0} #define wippersnapper_gps_GPSDateTime_init_default {0, 0, 0, 0, 0, 0, 0} #define wippersnapper_gps_GPSRMCResponse_init_default {false, wippersnapper_gps_GPSDateTime_init_default, "", "", "", "", "", "", ""} #define wippersnapper_gps_GPGGAResponse_init_default {false, wippersnapper_gps_GPSDateTime_init_default, "", "", "", "", 0, 0, "", "", ""} #define wippersnapper_gps_GPSEvent_init_default {0, {wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default, wippersnapper_gps_GPSRMCResponse_init_default}, 0, {wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default, wippersnapper_gps_GPGGAResponse_init_default}} -#define wippersnapper_gps_GPSB2D_init_zero {0} #define wippersnapper_gps_GPSD2B_init_zero {0, {wippersnapper_gps_GPSEvent_init_zero}} #define wippersnapper_gps_GPSConfig_init_zero {0, {"", "", "", "", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0} #define wippersnapper_gps_GPSDateTime_init_zero {0, 0, 0, 0, 0, 0, 0} @@ -143,11 +133,6 @@ extern "C" { #define wippersnapper_gps_GPSD2B_gps_event_tag 10 /* Struct field encoding specification for nanopb */ -#define wippersnapper_gps_GPSB2D_FIELDLIST(X, a) \ - -#define wippersnapper_gps_GPSB2D_CALLBACK NULL -#define wippersnapper_gps_GPSB2D_DEFAULT NULL - #define wippersnapper_gps_GPSD2B_FIELDLIST(X, a) \ X(a, STATIC, ONEOF, MESSAGE, (payload,gps_event,payload.gps_event), 10) #define wippersnapper_gps_GPSD2B_CALLBACK NULL @@ -208,7 +193,6 @@ X(a, STATIC, REPEATED, MESSAGE, gga_responses, 2) #define wippersnapper_gps_GPSEvent_rmc_responses_MSGTYPE wippersnapper_gps_GPSRMCResponse #define wippersnapper_gps_GPSEvent_gga_responses_MSGTYPE wippersnapper_gps_GPGGAResponse -extern const pb_msgdesc_t wippersnapper_gps_GPSB2D_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSD2B_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSConfig_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSDateTime_msg; @@ -217,7 +201,6 @@ extern const pb_msgdesc_t wippersnapper_gps_GPGGAResponse_msg; extern const pb_msgdesc_t wippersnapper_gps_GPSEvent_msg; /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ -#define wippersnapper_gps_GPSB2D_fields &wippersnapper_gps_GPSB2D_msg #define wippersnapper_gps_GPSD2B_fields &wippersnapper_gps_GPSD2B_msg #define wippersnapper_gps_GPSConfig_fields &wippersnapper_gps_GPSConfig_msg #define wippersnapper_gps_GPSDateTime_fields &wippersnapper_gps_GPSDateTime_msg @@ -228,7 +211,6 @@ extern const pb_msgdesc_t wippersnapper_gps_GPSEvent_msg; /* Maximum encoded size of messages (where known) */ #define WIPPERSNAPPER_GPS_GPS_PB_H_MAX_SIZE wippersnapper_gps_GPSD2B_size #define wippersnapper_gps_GPGGAResponse_size 168 -#define wippersnapper_gps_GPSB2D_size 0 #define wippersnapper_gps_GPSConfig_size 1787 #define wippersnapper_gps_GPSD2B_size 3133 #define wippersnapper_gps_GPSDateTime_size 77 diff --git a/src/protos/i2c.pb.c b/src/protos/i2c.pb.c index 7ff2236e9..0ebc065b4 100644 --- a/src/protos/i2c.pb.c +++ b/src/protos/i2c.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "i2c.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/i2c.pb.h b/src/protos/i2c.pb.h index f6e3922f5..d603fe4e9 100644 --- a/src/protos/i2c.pb.h +++ b/src/protos/i2c.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_I2C_I2C_PB_H_INCLUDED #define PB_WIPPERSNAPPER_I2C_I2C_PB_H_INCLUDED diff --git a/src/protos/i2c_output.pb.c b/src/protos/i2c_output.pb.c index d8474b88b..c32ea9b25 100644 --- a/src/protos/i2c_output.pb.c +++ b/src/protos/i2c_output.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "i2c_output.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/i2c_output.pb.h b/src/protos/i2c_output.pb.h index e14e12dfd..c2450349c 100644 --- a/src/protos/i2c_output.pb.h +++ b/src/protos/i2c_output.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_I2C_OUTPUT_I2C_OUTPUT_PB_H_INCLUDED #define PB_WIPPERSNAPPER_I2C_OUTPUT_I2C_OUTPUT_PB_H_INCLUDED diff --git a/src/protos/pixels.pb.c b/src/protos/pixels.pb.c index 1ff34b792..1f698537a 100644 --- a/src/protos/pixels.pb.c +++ b/src/protos/pixels.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "pixels.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/pixels.pb.h b/src/protos/pixels.pb.h index cc110d9b0..d9817fe86 100644 --- a/src/protos/pixels.pb.h +++ b/src/protos/pixels.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_PIXELS_PIXELS_PB_H_INCLUDED #define PB_WIPPERSNAPPER_PIXELS_PIXELS_PB_H_INCLUDED diff --git a/src/protos/pwm.pb.c b/src/protos/pwm.pb.c index 65f3e3b8f..f7b93c7c5 100644 --- a/src/protos/pwm.pb.c +++ b/src/protos/pwm.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "pwm.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/pwm.pb.h b/src/protos/pwm.pb.h index 0ed1a8daa..b87c4c709 100644 --- a/src/protos/pwm.pb.h +++ b/src/protos/pwm.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_PWM_PWM_PB_H_INCLUDED #define PB_WIPPERSNAPPER_PWM_PWM_PB_H_INCLUDED diff --git a/src/protos/sensor.pb.c b/src/protos/sensor.pb.c index 6aabf0885..25f768b4c 100644 --- a/src/protos/sensor.pb.c +++ b/src/protos/sensor.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "sensor.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/sensor.pb.h b/src/protos/sensor.pb.h index ca74080a0..c185ed236 100644 --- a/src/protos/sensor.pb.h +++ b/src/protos/sensor.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_SENSOR_SENSOR_PB_H_INCLUDED #define PB_WIPPERSNAPPER_SENSOR_SENSOR_PB_H_INCLUDED diff --git a/src/protos/servo.pb.c b/src/protos/servo.pb.c index 9b30a2536..041f1295e 100644 --- a/src/protos/servo.pb.c +++ b/src/protos/servo.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "servo.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/servo.pb.h b/src/protos/servo.pb.h index 891f9096c..ea4934da0 100644 --- a/src/protos/servo.pb.h +++ b/src/protos/servo.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_SERVO_SERVO_PB_H_INCLUDED #define PB_WIPPERSNAPPER_SERVO_SERVO_PB_H_INCLUDED diff --git a/src/protos/signal.pb.c b/src/protos/signal.pb.c index 97a7a6367..ff41bc7e1 100644 --- a/src/protos/signal.pb.c +++ b/src/protos/signal.pb.c @@ -1,12 +1,12 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "signal.pb.h" #if PB_PROTO_HEADER_VERSION != 40 #error Regenerate this file with the current version of nanopb generator. #endif -PB_BIND(wippersnapper_signal_BrokerToDevice, wippersnapper_signal_BrokerToDevice, 2) +PB_BIND(wippersnapper_signal_BrokerToDevice, wippersnapper_signal_BrokerToDevice, 4) PB_BIND(wippersnapper_signal_DeviceToBroker, wippersnapper_signal_DeviceToBroker, 4) diff --git a/src/protos/signal.pb.h b/src/protos/signal.pb.h index 4905d8c05..8c043d2c1 100644 --- a/src/protos/signal.pb.h +++ b/src/protos/signal.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_SIGNAL_SIGNAL_PB_H_INCLUDED #define PB_WIPPERSNAPPER_SIGNAL_SIGNAL_PB_H_INCLUDED @@ -14,6 +14,7 @@ #include "pwm.pb.h" #include "servo.pb.h" #include "uart.pb.h" +#include "gps.pb.h" #if PB_PROTO_HEADER_VERSION != 40 #error Regenerate this file with the current version of nanopb generator. @@ -40,7 +41,7 @@ typedef struct _wippersnapper_signal_BrokerToDevice { wippersnapper_pixels_PixelsB2D pixels; wippersnapper_ds18x20_Ds18x20B2D ds18x20; wippersnapper_uart_UartB2D uart; - wippersnapper_i2c_I2cB2D i2c; /* wippersnapper.gps.GPSB2D gps = xx; */ + wippersnapper_i2c_I2cB2D i2c; } payload; } wippersnapper_signal_BrokerToDevice; @@ -62,7 +63,8 @@ typedef struct _wippersnapper_signal_DeviceToBroker { wippersnapper_pixels_PixelsD2B pixels; wippersnapper_ds18x20_Ds18x20D2B ds18x20; wippersnapper_uart_UartD2B uart; - wippersnapper_i2c_I2cD2B i2c; /* wippersnapper.gps.GPSD2B gps = xx; */ + wippersnapper_i2c_I2cD2B i2c; + wippersnapper_gps_GPSD2B gps; } payload; } wippersnapper_signal_DeviceToBroker; @@ -97,6 +99,7 @@ extern "C" { #define wippersnapper_signal_DeviceToBroker_ds18x20_tag 35 #define wippersnapper_signal_DeviceToBroker_uart_tag 36 #define wippersnapper_signal_DeviceToBroker_i2c_tag 37 +#define wippersnapper_signal_DeviceToBroker_gps_tag 38 /* Struct field encoding specification for nanopb */ #define wippersnapper_signal_BrokerToDevice_FIELDLIST(X, a) \ @@ -132,7 +135,8 @@ X(a, STATIC, ONEOF, MSG_W_CB, (payload,pwm,payload.pwm), 33) \ X(a, STATIC, ONEOF, MSG_W_CB, (payload,pixels,payload.pixels), 34) \ X(a, STATIC, ONEOF, MSG_W_CB, (payload,ds18x20,payload.ds18x20), 35) \ X(a, STATIC, ONEOF, MSG_W_CB, (payload,uart,payload.uart), 36) \ -X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c,payload.i2c), 37) +X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c,payload.i2c), 37) \ +X(a, STATIC, ONEOF, MSG_W_CB, (payload,gps,payload.gps), 38) #define wippersnapper_signal_DeviceToBroker_CALLBACK NULL #define wippersnapper_signal_DeviceToBroker_DEFAULT NULL #define wippersnapper_signal_DeviceToBroker_payload_checkin_MSGTYPE wippersnapper_checkin_CheckinD2B @@ -144,6 +148,7 @@ X(a, STATIC, ONEOF, MSG_W_CB, (payload,i2c,payload.i2c), 37) #define wippersnapper_signal_DeviceToBroker_payload_ds18x20_MSGTYPE wippersnapper_ds18x20_Ds18x20D2B #define wippersnapper_signal_DeviceToBroker_payload_uart_MSGTYPE wippersnapper_uart_UartD2B #define wippersnapper_signal_DeviceToBroker_payload_i2c_MSGTYPE wippersnapper_i2c_I2cD2B +#define wippersnapper_signal_DeviceToBroker_payload_gps_MSGTYPE wippersnapper_gps_GPSD2B extern const pb_msgdesc_t wippersnapper_signal_BrokerToDevice_msg; extern const pb_msgdesc_t wippersnapper_signal_DeviceToBroker_msg; @@ -157,7 +162,7 @@ extern const pb_msgdesc_t wippersnapper_signal_DeviceToBroker_msg; union wippersnapper_signal_BrokerToDevice_payload_size_union {char f20[(7 + wippersnapper_checkin_CheckinB2D_size)]; char f30[(7 + wippersnapper_digitalio_DigitalIOB2D_size)]; char f36[(7 + wippersnapper_uart_UartB2D_size)]; char f0[1924];}; #endif #if defined(wippersnapper_digitalio_DigitalIOD2B_size) && defined(wippersnapper_analogio_AnalogIOD2B_size) && defined(wippersnapper_ds18x20_Ds18x20D2B_size) && defined(wippersnapper_uart_UartD2B_size) && defined(wippersnapper_i2c_I2cD2B_size) -union wippersnapper_signal_DeviceToBroker_payload_size_union {char f30[(7 + wippersnapper_digitalio_DigitalIOD2B_size)]; char f31[(7 + wippersnapper_analogio_AnalogIOD2B_size)]; char f35[(7 + wippersnapper_ds18x20_Ds18x20D2B_size)]; char f36[(7 + wippersnapper_uart_UartD2B_size)]; char f37[(7 + wippersnapper_i2c_I2cD2B_size)]; char f0[96];}; +union wippersnapper_signal_DeviceToBroker_payload_size_union {char f30[(7 + wippersnapper_digitalio_DigitalIOD2B_size)]; char f31[(7 + wippersnapper_analogio_AnalogIOD2B_size)]; char f35[(7 + wippersnapper_ds18x20_Ds18x20D2B_size)]; char f36[(7 + wippersnapper_uart_UartD2B_size)]; char f37[(7 + wippersnapper_i2c_I2cD2B_size)]; char f0[3137];}; #endif #if defined(wippersnapper_checkin_CheckinB2D_size) && defined(wippersnapper_digitalio_DigitalIOB2D_size) && defined(wippersnapper_uart_UartB2D_size) #define WIPPERSNAPPER_SIGNAL_SIGNAL_PB_H_MAX_SIZE wippersnapper_signal_BrokerToDevice_size diff --git a/src/protos/uart.pb.c b/src/protos/uart.pb.c index 12dda9748..c150d80a1 100644 --- a/src/protos/uart.pb.c +++ b/src/protos/uart.pb.c @@ -1,5 +1,5 @@ /* Automatically generated nanopb constant definitions */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #include "uart.pb.h" #if PB_PROTO_HEADER_VERSION != 40 diff --git a/src/protos/uart.pb.h b/src/protos/uart.pb.h index bcd0471c4..8f233e770 100644 --- a/src/protos/uart.pb.h +++ b/src/protos/uart.pb.h @@ -1,5 +1,5 @@ /* Automatically generated nanopb header */ -/* Generated by nanopb-0.4.8 */ +/* Generated by nanopb-0.4.8 at Wed Nov 12 15:48:51 2025. */ #ifndef PB_WIPPERSNAPPER_UART_UART_PB_H_INCLUDED #define PB_WIPPERSNAPPER_UART_UART_PB_H_INCLUDED diff --git a/src/provisioning/sdcard/ws_sdcard.cpp b/src/provisioning/sdcard/ws_sdcard.cpp index fb11430c0..94fed83f0 100644 --- a/src/provisioning/sdcard/ws_sdcard.cpp +++ b/src/provisioning/sdcard/ws_sdcard.cpp @@ -731,9 +731,9 @@ bool ws_sdcard::parseConfigFile() { return false; } - msg_signal_b2d.which_payload = +/* msg_signal_b2d.which_payload = wippersnapper_signal_BrokerToDevice_digitalio_add_tag; - msg_signal_b2d.payload.digitalio_add = msg_DigitalIOAdd; + msg_signal_b2d.payload.digitalio_add = msg_DigitalIOAdd; */ } else if (strcmp(component_api_type, "analogio") == 0) { WS_DEBUG_PRINTLN("[SD] AnalogIO component found, decoding JSON to PB..."); wippersnapper_analogio_AnalogIOAdd msg_AnalogIOAdd = From 5e2dd26ea086cae70e6cb5b00f898e297fdb53fc Mon Sep 17 00:00:00 2001 From: brentru Date: Wed, 12 Nov 2025 16:20:08 -0500 Subject: [PATCH 3/7] featheresp32v2 SUCCESS 00:00:34.634 --- src/Wippersnapper_demo.ino.cpp | 21 --------------------- src/components/pwm/controller.cpp | 4 ++-- src/provisioning/sdcard/ws_sdcard.cpp | 12 ++++++------ 3 files changed, 8 insertions(+), 29 deletions(-) delete mode 100644 src/Wippersnapper_demo.ino.cpp diff --git a/src/Wippersnapper_demo.ino.cpp b/src/Wippersnapper_demo.ino.cpp deleted file mode 100644 index d401831f5..000000000 --- a/src/Wippersnapper_demo.ino.cpp +++ /dev/null @@ -1,21 +0,0 @@ -# 1 "/var/folders/ff/dmzflvf52tq9kzvt6g8jglxw0000gn/T/tmpvab_6n0x" -#include -# 1 "/Users/brentrubell/Documents/Arduino/libraries/Adafruit_Wippersnapper_Arduino/src/Wippersnapper_demo.ino" -# 11 "/Users/brentrubell/Documents/Arduino/libraries/Adafruit_Wippersnapper_Arduino/src/Wippersnapper_demo.ino" -#include "ws_adapters.h" -ws_adapter_wifi wipper; - - -#define WS_DEBUG -void setup(); -void loop(); -#line 17 "/Users/brentrubell/Documents/Arduino/libraries/Adafruit_Wippersnapper_Arduino/src/Wippersnapper_demo.ino" -void setup() { - Serial.begin(115200); - while (!Serial) - delay(10); - wipper.provision(); - wipper.connect(); -} - -void loop() { wipper.run(); } \ No newline at end of file diff --git a/src/components/pwm/controller.cpp b/src/components/pwm/controller.cpp index 70053ee51..7cec76f0b 100644 --- a/src/components/pwm/controller.cpp +++ b/src/components/pwm/controller.cpp @@ -172,8 +172,8 @@ bool PWMController::Handle_PWM_Write_Frequency(pb_istream_t *stream) { /* wippersnapper_pwm_PWMWriteFrequency msg_write_frequency = *_pwm_model->GetPWMWriteFrequencyMsg(); uint8_t pin = atoi(msg_write_frequency.pin + 1); */ - //int pin_idx; - pin_idx = GetPWMHardwareIdx(pin); + int pin_idx; + //pin_idx = GetPWMHardwareIdx(pin); if (pin_idx == -1) { WS_DEBUG_PRINTLN("[pwm] Error: pin not found!"); return false; diff --git a/src/provisioning/sdcard/ws_sdcard.cpp b/src/provisioning/sdcard/ws_sdcard.cpp index 94fed83f0..498f18cf6 100644 --- a/src/provisioning/sdcard/ws_sdcard.cpp +++ b/src/provisioning/sdcard/ws_sdcard.cpp @@ -748,9 +748,9 @@ bool ws_sdcard::parseConfigFile() { return false; } - msg_signal_b2d.which_payload = +/* msg_signal_b2d.which_payload = wippersnapper_signal_BrokerToDevice_analogio_add_tag; - msg_signal_b2d.payload.analogio_add = msg_AnalogIOAdd; + msg_signal_b2d.payload.analogio_add = msg_AnalogIOAdd; */ } else if (strcmp(component_api_type, "ds18x20") == 0) { WS_DEBUG_PRINTLN("[SD] Ds18x20 component found, decoding JSON to PB..."); wippersnapper_ds18x20_Ds18x20Add msg_DS18X20Add = @@ -766,9 +766,9 @@ bool ws_sdcard::parseConfigFile() { WS_DEBUG_PRINTLN(component["pinName"] | UNKNOWN_VALUE); return false; } - msg_signal_b2d.which_payload = +/* msg_signal_b2d.which_payload = wippersnapper_signal_BrokerToDevice_ds18x20_add_tag; - msg_signal_b2d.payload.ds18x20_add = msg_DS18X20Add; + msg_signal_b2d.payload.ds18x20_add = msg_DS18X20Add; */ } else if (strcmp(component_api_type, "i2c") == 0) { WS_DEBUG_PRINTLN("[SD] I2C component found, decoding JSON to PB..."); wippersnapper_i2c_I2cDeviceAddOrReplace msg_i2c_add_replace = @@ -777,9 +777,9 @@ bool ws_sdcard::parseConfigFile() { WS_DEBUG_PRINTLN("[SD] Runtime Error: Unable to parse I2C Component"); return false; } - msg_signal_b2d.which_payload = +/* msg_signal_b2d.which_payload = wippersnapper_signal_BrokerToDevice_i2c_device_add_replace_tag; - msg_signal_b2d.payload.i2c_device_add_replace = msg_i2c_add_replace; + msg_signal_b2d.payload.i2c_device_add_replace = msg_i2c_add_replace; */ } else { WS_DEBUG_PRINTLN("[SD] Runtime Error: Unknown Component API Type: " + String(component_api_type)); From 0b5d1fead27b0398d273bd46944d9a20a8158b37 Mon Sep 17 00:00:00 2001 From: brentru Date: Thu, 13 Nov 2025 12:08:09 -0500 Subject: [PATCH 4/7] Update for D2b envelope checkin req. --- src/Wippersnapper_V2.cpp | 505 ++++++++++++++++--------------- src/Wippersnapper_V2.h | 12 +- src/components/checkin/model.cpp | 50 ++- src/components/checkin/model.h | 6 + 4 files changed, 316 insertions(+), 257 deletions(-) diff --git a/src/Wippersnapper_V2.cpp b/src/Wippersnapper_V2.cpp index d94ca37a2..a7a5aa7d4 100644 --- a/src/Wippersnapper_V2.cpp +++ b/src/Wippersnapper_V2.cpp @@ -48,6 +48,7 @@ Wippersnapper_V2::Wippersnapper_V2() { // Initialize model classes WsV2.sensorModel = new SensorModel(); + WsV2.CheckInModel = new CheckinModel(); // Initialize controller classes WsV2.digital_io_controller = new DigitalIOController(); @@ -303,164 +304,164 @@ bool handleCheckinResponse(pb_istream_t *stream) { bool cbDecodeBrokerToDevice(pb_istream_t *stream, const pb_field_t *field, void **arg) { (void)arg; // marking unused parameters to avoid compiler warning -/* - switch (field->tag) { - case wippersnapper_signal_BrokerToDevice_checkin_response_tag: - WS_DEBUG_PRINTLN("-> Checkin Response Message Type"); - WS_DEBUG_PRINT("Handling Checkin Response..."); - if (!handleCheckinResponse(stream)) { - return false; - } - WS_DEBUG_PRINTLN("Handled!"); - break; - case wippersnapper_signal_BrokerToDevice_digitalio_add_tag: - WS_DEBUG_PRINTLN("-> DigitalIO Add Message Type"); - if (!WsV2.digital_io_controller->Handle_DigitalIO_Add(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_digitalio_remove_tag: - WS_DEBUG_PRINTLN("-> DigitalIO Remove Message Type"); - if (!WsV2.digital_io_controller->Handle_DigitalIO_Remove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_digitalio_write_tag: - WS_DEBUG_PRINTLN("-> DigitalIO Write Message Type"); - if (!WsV2.digital_io_controller->Handle_DigitalIO_Write(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_analogio_add_tag: - WS_DEBUG_PRINTLN("-> AnalogIO Add Message Type"); - if (!WsV2.analogio_controller->Handle_AnalogIOAdd(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_analogio_remove_tag: - WS_DEBUG_PRINTLN("-> AnalogIO Remove Message Type"); - if (!WsV2.analogio_controller->Handle_AnalogIORemove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_ds18x20_add_tag: - WS_DEBUG_PRINTLN("-> DS18X20 Add Message Type"); - if (!WsV2._ds18x20_controller->Handle_Ds18x20Add(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_ds18x20_remove_tag: - WS_DEBUG_PRINTLN("-> DS18X20 Remove Message Type"); - if (!WsV2._ds18x20_controller->Handle_Ds18x20Remove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_i2c_device_add_replace_tag: - WS_DEBUG_PRINTLN("-> I2C Device Add/Replace Message Type"); - if (!WsV2._i2c_controller->Handle_I2cDeviceAddOrReplace(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_i2c_bus_scan_tag: - WS_DEBUG_PRINTLN("-> I2C Bus Scan Message Type"); - if (!WsV2._i2c_controller->Handle_I2cBusScan(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_i2c_device_remove_tag: - WS_DEBUG_PRINTLN("-> I2C Device Remove Message Type"); - if (!WsV2._i2c_controller->Handle_I2cDeviceRemove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_i2c_device_output_write_tag: - WS_DEBUG_PRINTLN("-> I2C Device Output Write Message Type"); - if (!WsV2._i2c_controller->Handle_I2cDeviceOutputWrite(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pixels_add_tag: - WS_DEBUG_PRINTLN("-> Pixels Add Message Type"); - if (!WsV2._pixels_controller->Handle_Pixels_Add(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pixels_remove_tag: - WS_DEBUG_PRINTLN("-> Pixels Remove Message Type"); - if (!WsV2._pixels_controller->Handle_Pixels_Remove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pixels_write_tag: - WS_DEBUG_PRINTLN("-> Pixels Write Message Type"); - if (!WsV2._pixels_controller->Handle_Pixels_Write(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pwm_add_tag: - WS_DEBUG_PRINTLN("-> PWM Add Message Type"); - if (!WsV2._pwm_controller->Handle_PWM_Add(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pwm_write_duty_tag: - WS_DEBUG_PRINTLN("-> PWM Write Duty Cycle Message Type"); - if (!WsV2._pwm_controller->Handle_PWM_Write_DutyCycle(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pwm_write_freq_tag: - WS_DEBUG_PRINTLN("-> PWM Write Frequency Message Type"); - if (!WsV2._pwm_controller->Handle_PWM_Write_Frequency(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_pwm_remove_tag: - WS_DEBUG_PRINTLN("-> PWM Remove Message Type"); - if (!WsV2._pwm_controller->Handle_PWM_Remove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_servo_add_tag: - WS_DEBUG_PRINTLN("-> Servo Add Message Type"); - if (!WsV2._servo_controller->Handle_Servo_Add(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_servo_write_tag: - WS_DEBUG_PRINTLN("-> Servo Write Message Type"); - if (!WsV2._servo_controller->Handle_Servo_Write(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_servo_remove_tag: - WS_DEBUG_PRINTLN("-> Servo Remove Message Type"); - if (!WsV2._servo_controller->Handle_Servo_Remove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_uart_add_tag: - WS_DEBUG_PRINTLN("-> UART Add Message Type"); - if (!WsV2._uart_controller->Handle_UartAdd(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_uart_remove_tag: - WS_DEBUG_PRINTLN("-> UART Remove Message Type"); - if (!WsV2._uart_controller->Handle_UartRemove(stream)) { - return false; - } - break; - case wippersnapper_signal_BrokerToDevice_uart_write_tag: - WS_DEBUG_PRINTLN("-> UART Write Message Type"); - if (!WsV2._uart_controller->Handle_UartWrite(stream)) { - return false; - } - break; - default: - WS_DEBUG_PRINTLN("ERROR: BrokerToDevice message type not found!"); - return false; - } */ + /* + switch (field->tag) { + case wippersnapper_signal_BrokerToDevice_checkin_response_tag: + WS_DEBUG_PRINTLN("-> Checkin Response Message Type"); + WS_DEBUG_PRINT("Handling Checkin Response..."); + if (!handleCheckinResponse(stream)) { + return false; + } + WS_DEBUG_PRINTLN("Handled!"); + break; + case wippersnapper_signal_BrokerToDevice_digitalio_add_tag: + WS_DEBUG_PRINTLN("-> DigitalIO Add Message Type"); + if (!WsV2.digital_io_controller->Handle_DigitalIO_Add(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_digitalio_remove_tag: + WS_DEBUG_PRINTLN("-> DigitalIO Remove Message Type"); + if (!WsV2.digital_io_controller->Handle_DigitalIO_Remove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_digitalio_write_tag: + WS_DEBUG_PRINTLN("-> DigitalIO Write Message Type"); + if (!WsV2.digital_io_controller->Handle_DigitalIO_Write(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_analogio_add_tag: + WS_DEBUG_PRINTLN("-> AnalogIO Add Message Type"); + if (!WsV2.analogio_controller->Handle_AnalogIOAdd(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_analogio_remove_tag: + WS_DEBUG_PRINTLN("-> AnalogIO Remove Message Type"); + if (!WsV2.analogio_controller->Handle_AnalogIORemove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_ds18x20_add_tag: + WS_DEBUG_PRINTLN("-> DS18X20 Add Message Type"); + if (!WsV2._ds18x20_controller->Handle_Ds18x20Add(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_ds18x20_remove_tag: + WS_DEBUG_PRINTLN("-> DS18X20 Remove Message Type"); + if (!WsV2._ds18x20_controller->Handle_Ds18x20Remove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_i2c_device_add_replace_tag: + WS_DEBUG_PRINTLN("-> I2C Device Add/Replace Message Type"); + if (!WsV2._i2c_controller->Handle_I2cDeviceAddOrReplace(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_i2c_bus_scan_tag: + WS_DEBUG_PRINTLN("-> I2C Bus Scan Message Type"); + if (!WsV2._i2c_controller->Handle_I2cBusScan(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_i2c_device_remove_tag: + WS_DEBUG_PRINTLN("-> I2C Device Remove Message Type"); + if (!WsV2._i2c_controller->Handle_I2cDeviceRemove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_i2c_device_output_write_tag: + WS_DEBUG_PRINTLN("-> I2C Device Output Write Message Type"); + if (!WsV2._i2c_controller->Handle_I2cDeviceOutputWrite(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pixels_add_tag: + WS_DEBUG_PRINTLN("-> Pixels Add Message Type"); + if (!WsV2._pixels_controller->Handle_Pixels_Add(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pixels_remove_tag: + WS_DEBUG_PRINTLN("-> Pixels Remove Message Type"); + if (!WsV2._pixels_controller->Handle_Pixels_Remove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pixels_write_tag: + WS_DEBUG_PRINTLN("-> Pixels Write Message Type"); + if (!WsV2._pixels_controller->Handle_Pixels_Write(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pwm_add_tag: + WS_DEBUG_PRINTLN("-> PWM Add Message Type"); + if (!WsV2._pwm_controller->Handle_PWM_Add(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pwm_write_duty_tag: + WS_DEBUG_PRINTLN("-> PWM Write Duty Cycle Message Type"); + if (!WsV2._pwm_controller->Handle_PWM_Write_DutyCycle(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pwm_write_freq_tag: + WS_DEBUG_PRINTLN("-> PWM Write Frequency Message Type"); + if (!WsV2._pwm_controller->Handle_PWM_Write_Frequency(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_pwm_remove_tag: + WS_DEBUG_PRINTLN("-> PWM Remove Message Type"); + if (!WsV2._pwm_controller->Handle_PWM_Remove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_servo_add_tag: + WS_DEBUG_PRINTLN("-> Servo Add Message Type"); + if (!WsV2._servo_controller->Handle_Servo_Add(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_servo_write_tag: + WS_DEBUG_PRINTLN("-> Servo Write Message Type"); + if (!WsV2._servo_controller->Handle_Servo_Write(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_servo_remove_tag: + WS_DEBUG_PRINTLN("-> Servo Remove Message Type"); + if (!WsV2._servo_controller->Handle_Servo_Remove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_uart_add_tag: + WS_DEBUG_PRINTLN("-> UART Add Message Type"); + if (!WsV2._uart_controller->Handle_UartAdd(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_uart_remove_tag: + WS_DEBUG_PRINTLN("-> UART Remove Message Type"); + if (!WsV2._uart_controller->Handle_UartRemove(stream)) { + return false; + } + break; + case wippersnapper_signal_BrokerToDevice_uart_write_tag: + WS_DEBUG_PRINTLN("-> UART Write Message Type"); + if (!WsV2._uart_controller->Handle_UartWrite(stream)) { + return false; + } + break; + default: + WS_DEBUG_PRINTLN("ERROR: BrokerToDevice message type not found!"); + return false; + } */ // once this is returned, pb_dec_submessage() // decodes the submessage contents. return true; @@ -965,85 +966,86 @@ bool Wippersnapper_V2::PublishSignal(pb_size_t which_payload, void *payload) { size_t szMessageBuf; wippersnapper_signal_DeviceToBroker MsgSignal = wippersnapper_signal_DeviceToBroker_init_default; -/* - // Fill generic signal payload with the payload from the args. - WS_DEBUG_PRINT("Signal Payload Type: "); - switch (which_payload) { - case wippersnapper_signal_DeviceToBroker_checkin_request_tag: - WS_DEBUG_PRINTLN("CheckinRequest"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_checkin_request_tag; - MsgSignal.payload.checkin_request = - *(wippersnapper_checkin_CheckinRequest *)payload; - break; - case wippersnapper_signal_DeviceToBroker_digitalio_event_tag: - WS_DEBUG_PRINTLN("DigitalIOEvent"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_digitalio_event_tag; - MsgSignal.payload.digitalio_event = - *(wippersnapper_digitalio_DigitalIOEvent *)payload; - break; - case wippersnapper_signal_DeviceToBroker_analogio_event_tag: - WS_DEBUG_PRINTLN("AnalogIOEvent"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_analogio_event_tag; - MsgSignal.payload.analogio_event = - *(wippersnapper_analogio_AnalogIOEvent *)payload; - break; - case wippersnapper_signal_DeviceToBroker_ds18x20_added_tag: - WS_DEBUG_PRINTLN("DS18X20Added"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_ds18x20_added_tag; - MsgSignal.payload.ds18x20_added = - *(wippersnapper_ds18x20_Ds18x20Added *)payload; - break; - case wippersnapper_signal_DeviceToBroker_ds18x20_event_tag: - WS_DEBUG_PRINTLN("DS18X20Event"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_ds18x20_event_tag; - MsgSignal.payload.ds18x20_event = - *(wippersnapper_ds18x20_Ds18x20Event *)payload; - break; - case wippersnapper_signal_DeviceToBroker_pixels_added_tag: - WS_DEBUG_PRINTLN("PixelsAdded"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_pixels_added_tag; - MsgSignal.payload.pixels_added = - *(wippersnapper_pixels_PixelsAdded *)payload; - break; - case wippersnapper_signal_DeviceToBroker_pwm_added_tag: - WS_DEBUG_PRINTLN("PWMAdded"); - MsgSignal.which_payload = wippersnapper_signal_DeviceToBroker_pwm_added_tag; - MsgSignal.payload.pwm_added = *(wippersnapper_pwm_PWMAdded *)payload; - break; - case wippersnapper_signal_DeviceToBroker_servo_added_tag: - WS_DEBUG_PRINTLN("ServoAdded"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_servo_added_tag; - MsgSignal.payload.servo_added = *(wippersnapper_servo_ServoAdded *)payload; - break; - case wippersnapper_signal_DeviceToBroker_uart_added_tag: - WS_DEBUG_PRINTLN("UARTAdded"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_uart_added_tag; - MsgSignal.payload.uart_added = *(wippersnapper_uart_UartAdded *)payload; - break; - case wippersnapper_signal_DeviceToBroker_uart_input_event_tag: - WS_DEBUG_PRINTLN("UARTInputEvent"); - MsgSignal.which_payload = - wippersnapper_signal_DeviceToBroker_uart_input_event_tag; - MsgSignal.payload.uart_input_event = - *(wippersnapper_uart_UartInputEvent *)payload; - break; - case wippersnapper_signal_DeviceToBroker_gps_event_tag: - WS_DEBUG_PRINTLN("GPSEvent"); - MsgSignal.which_payload = wippersnapper_signal_DeviceToBroker_gps_event_tag; - MsgSignal.payload.gps_event = *(wippersnapper_gps_GPSEvent *)payload; - break; - default: - WS_DEBUG_PRINTLN("ERROR: Invalid signal payload type, bailing out!"); - return false; - } */ + /* + // Fill generic signal payload with the payload from the args. + WS_DEBUG_PRINT("Signal Payload Type: "); + switch (which_payload) { + case wippersnapper_signal_DeviceToBroker_checkin_request_tag: + WS_DEBUG_PRINTLN("CheckinRequest"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_checkin_request_tag; + MsgSignal.payload.checkin_request = + *(wippersnapper_checkin_CheckinRequest *)payload; + break; + case wippersnapper_signal_DeviceToBroker_digitalio_event_tag: + WS_DEBUG_PRINTLN("DigitalIOEvent"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_digitalio_event_tag; + MsgSignal.payload.digitalio_event = + *(wippersnapper_digitalio_DigitalIOEvent *)payload; + break; + case wippersnapper_signal_DeviceToBroker_analogio_event_tag: + WS_DEBUG_PRINTLN("AnalogIOEvent"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_analogio_event_tag; + MsgSignal.payload.analogio_event = + *(wippersnapper_analogio_AnalogIOEvent *)payload; + break; + case wippersnapper_signal_DeviceToBroker_ds18x20_added_tag: + WS_DEBUG_PRINTLN("DS18X20Added"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_ds18x20_added_tag; + MsgSignal.payload.ds18x20_added = + *(wippersnapper_ds18x20_Ds18x20Added *)payload; + break; + case wippersnapper_signal_DeviceToBroker_ds18x20_event_tag: + WS_DEBUG_PRINTLN("DS18X20Event"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_ds18x20_event_tag; + MsgSignal.payload.ds18x20_event = + *(wippersnapper_ds18x20_Ds18x20Event *)payload; + break; + case wippersnapper_signal_DeviceToBroker_pixels_added_tag: + WS_DEBUG_PRINTLN("PixelsAdded"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_pixels_added_tag; + MsgSignal.payload.pixels_added = + *(wippersnapper_pixels_PixelsAdded *)payload; + break; + case wippersnapper_signal_DeviceToBroker_pwm_added_tag: + WS_DEBUG_PRINTLN("PWMAdded"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_pwm_added_tag; + MsgSignal.payload.pwm_added = *(wippersnapper_pwm_PWMAdded *)payload; + break; + case wippersnapper_signal_DeviceToBroker_servo_added_tag: + WS_DEBUG_PRINTLN("ServoAdded"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_servo_added_tag; + MsgSignal.payload.servo_added = *(wippersnapper_servo_ServoAdded + *)payload; break; case wippersnapper_signal_DeviceToBroker_uart_added_tag: + WS_DEBUG_PRINTLN("UARTAdded"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_uart_added_tag; + MsgSignal.payload.uart_added = *(wippersnapper_uart_UartAdded *)payload; + break; + case wippersnapper_signal_DeviceToBroker_uart_input_event_tag: + WS_DEBUG_PRINTLN("UARTInputEvent"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_uart_input_event_tag; + MsgSignal.payload.uart_input_event = + *(wippersnapper_uart_UartInputEvent *)payload; + break; + case wippersnapper_signal_DeviceToBroker_gps_event_tag: + WS_DEBUG_PRINTLN("GPSEvent"); + MsgSignal.which_payload = + wippersnapper_signal_DeviceToBroker_gps_event_tag; + MsgSignal.payload.gps_event = *(wippersnapper_gps_GPSEvent *)payload; + break; + default: + WS_DEBUG_PRINTLN("ERROR: Invalid signal payload type, bailing out!"); + return false; + } */ // Get the encoded size of the signal message if (!pb_get_encoded_size(&szMessageBuf, @@ -1106,22 +1108,21 @@ bool Wippersnapper_V2::PublishSignal(pb_size_t which_payload, void *payload) { @returns True if the Checkin request message published successfully, False otherwise. */ -bool Wippersnapper_V2::CreateCheckinRequest() { - WS_DEBUG_PRINT("Creating the CheckinRequest message..."); - WsV2.CheckInModel = new CheckinModel(); - WsV2.CheckInModel->CreateCheckinRequest(WsV2.sUIDV2, WS_VERSION); - WS_DEBUG_PRINTLN("Created!"); - - WS_DEBUG_PRINT("Encoding the CheckinRequest message..."); - if (!WsV2.CheckInModel->EncodeCheckinRequest()) +bool Wippersnapper_V2::PublishCheckinRequest() { + // Attempt to fill and encode the D2b CheckinRequest message + if (!WsV2.CheckInModel->EncodeD2bCheckinRequest(WsV2.sUIDV2, WS_VERSION)) { + WS_DEBUG_PRINTLN( + "[checkin] ERROR: Failed to encode CheckinRequest message!"); return false; - WS_DEBUG_PRINTLN("Encoded!"); + } - WS_DEBUG_PRINT("Publishing Checkin Request..."); -/* if (!PublishSignal(wippersnapper_signal_DeviceToBroker_checkin_request_tag, - WsV2.CheckInModel->getCheckinRequest())) - return false; */ - WS_DEBUG_PRINTLN("Published!"); + // Attempt to publish the Device to Broker message to the broker + if (!PublishSignal(wippersnapper_signal_BrokerToDevice_checkin_tag, + WsV2.CheckInModel->getD2bCheckinRequest())) { + WS_DEBUG_PRINTLN( + "[checkin] ERROR: Failed to publish CheckinRequest message!"); + return false; + } return true; } @@ -1327,7 +1328,7 @@ void Wippersnapper_V2::connect() { WS_DEBUG_PRINTLN("Performing checkin handshake..."); // Publish the checkin request - if (!CreateCheckinRequest()) { + if (!PublishCheckinRequest()) { haltErrorV2("Unable to publish checkin request"); } // Handle the checkin response diff --git a/src/Wippersnapper_V2.h b/src/Wippersnapper_V2.h index e8b4382fa..02c3472b7 100644 --- a/src/Wippersnapper_V2.h +++ b/src/Wippersnapper_V2.h @@ -30,7 +30,9 @@ */ #ifdef WS_DEBUG #define WS_DEBUG_PRINT(...) \ - { WS_PRINTER.print(__VA_ARGS__); } /**< Print debug message to serial */ + { \ + WS_PRINTER.print(__VA_ARGS__); \ + } /**< Print debug message to serial */ #define WS_DEBUG_PRINTLN(...) \ { \ WS_PRINTER.println(__VA_ARGS__); \ @@ -42,9 +44,11 @@ } /**< Print debug message in hexadecimal */ #else #define WS_DEBUG_PRINT(...) \ - {} /**< Debug print */ + { \ + } /**< Debug print */ #define WS_DEBUG_PRINTLN(...) \ - {} /**< Debug println */ + { \ + } /**< Debug println */ #endif /*! @@ -195,7 +199,7 @@ class Wippersnapper_V2 { bool PublishSignal(pb_size_t which_payload, void *payload); // Checkin API - bool CreateCheckinRequest(); + bool PublishCheckinRequest(); void PollCheckinResponse(); // run() loop diff --git a/src/components/checkin/model.cpp b/src/components/checkin/model.cpp index 95b121a06..5df4c722d 100644 --- a/src/components/checkin/model.cpp +++ b/src/components/checkin/model.cpp @@ -31,6 +31,46 @@ CheckinModel::~CheckinModel() { memset(&_CheckinResponse, 0, sizeof(_CheckinResponse)); } +bool CheckinModel::EncodeD2bCheckinRequest(const char *hw_uid, + const char *fw_ver) { + // Validate input len + if (strlen(hw_uid) >= + sizeof(_CheckinD2B.payload.checkin_request.hardware_uid) || + strlen(fw_ver) >= + sizeof(_CheckinD2B.payload.checkin_request.firmware_version)) { + return false; + } + + // Zero-out the message envelope + memset(&_CheckinD2B, 0, sizeof(_CheckinD2B)); + // Set which_payload + _CheckinD2B.which_payload = + wippersnapper_checkin_CheckinD2B_checkin_request_tag; + // Safely fill the CheckinRequest sub-message payload + strncpy(_CheckinD2B.payload.checkin_request.hardware_uid, hw_uid, + sizeof(_CheckinD2B.payload.checkin_request.hardware_uid) - 1); + _CheckinD2B.payload.checkin_request + .hardware_uid[sizeof(_CheckinD2B.payload.checkin_request.hardware_uid) - + 1] = '\0'; + strncpy(_CheckinD2B.payload.checkin_request.firmware_version, fw_ver, + sizeof(_CheckinD2B.payload.checkin_request.firmware_version) - 1); + _CheckinD2B.payload.checkin_request.firmware_version + [sizeof(_CheckinD2B.payload.checkin_request.firmware_version) - 1] = '\0'; + + // Obtain size of the CheckinD2B message + size_t CheckinD2BSz; + if (!pb_get_encoded_size( + &CheckinD2BSz, wippersnapper_checkin_CheckinD2B_fields, &_CheckinD2B)) + return false; + // Create a temporary buffer for holding the CheckinD2B message + uint8_t buf[CheckinD2BSz]; + // Create a stream that will write to buf + pb_ostream_t msg_stream = pb_ostream_from_buffer(buf, sizeof(buf)); + // Attempt to encode the message + return pb_encode(&msg_stream, wippersnapper_checkin_CheckinD2B_fields, + &_CheckinD2B); +} + /*! @brief Fills and creates a CheckinRequest message @param hardware_uid @@ -116,6 +156,14 @@ wippersnapper_checkin_CheckinRequest *CheckinModel::getCheckinRequest() { return &_CheckinRequest; } +/*! + @brief Gets the CheckinD2B message + @returns CheckinD2B message pointer. +*/ +wippersnapper_checkin_CheckinD2B *CheckinModel::getD2bCheckinRequest() { + return &_CheckinD2B; +} + /*! @brief Sets the CheckinResponse message's total GPIO pins field @param total_gpio_pins @@ -159,4 +207,4 @@ void CheckinModel::setReferenceVoltage(float reference_voltage) { @brief Gets the CheckinResponse message's reference voltage field @returns Reference voltage. */ -float CheckinModel::getReferenceVoltage() { return _reference_voltage; } \ No newline at end of file +float CheckinModel::getReferenceVoltage() { return _reference_voltage; } diff --git a/src/components/checkin/model.h b/src/components/checkin/model.h index 2c17a82eb..36d34e38b 100644 --- a/src/components/checkin/model.h +++ b/src/components/checkin/model.h @@ -24,6 +24,10 @@ class CheckinModel { public: CheckinModel(); ~CheckinModel(); + // DeviceToBroker Message Envelope + bool EncodeD2bCheckinRequest(const char *hw_uid, const char *fw_ver); + wippersnapper_checkin_CheckinD2B *getD2bCheckinRequest(); + // Request Message void CreateCheckinRequest(const char *hardware_uid, const char *firmware_version); @@ -43,6 +47,8 @@ class CheckinModel { float getReferenceVoltage(); private: + wippersnapper_checkin_CheckinD2B + _CheckinD2B; ///< DeviceToBroker message envelope wippersnapper_checkin_CheckinRequest _CheckinRequest; wippersnapper_checkin_CheckinResponse _CheckinResponse; wippersnapper_checkin_CheckinResponse_Response _response; From dc41f619baed389321c3ae282cf74b6289e29507 Mon Sep 17 00:00:00 2001 From: brentru Date: Thu, 13 Nov 2025 14:57:21 -0500 Subject: [PATCH 5/7] Pipe thru controler --- src/Wippersnapper_V2.cpp | 14 ++++++ src/components/checkin/model.cpp | 33 ++++++++++++++ src/components/checkin/model.h | 10 ++++- src/components/digitalIO/controller.cpp | 57 ++++++++++++++++++++++++- src/components/digitalIO/controller.h | 4 +- 5 files changed, 113 insertions(+), 5 deletions(-) diff --git a/src/Wippersnapper_V2.cpp b/src/Wippersnapper_V2.cpp index a7a5aa7d4..e0df0664c 100644 --- a/src/Wippersnapper_V2.cpp +++ b/src/Wippersnapper_V2.cpp @@ -304,6 +304,20 @@ bool handleCheckinResponse(pb_istream_t *stream) { bool cbDecodeBrokerToDevice(pb_istream_t *stream, const pb_field_t *field, void **arg) { (void)arg; // marking unused parameters to avoid compiler warning + + // TODO: Refactored switch-case + switch(field->tag) { + case wippersnapper_signal_BrokerToDevice_checkin_tag: { + WS_DEBUG_PRINTLN("-> Checkin Message"); + if (!handleCheckinResponse(stream)) { + return false; + } + break; + default: + WS_DEBUG_PRINTLN("-> Unhandled B2D Message Type"); + break; + } + /* switch (field->tag) { case wippersnapper_signal_BrokerToDevice_checkin_response_tag: diff --git a/src/components/checkin/model.cpp b/src/components/checkin/model.cpp index 5df4c722d..2204b386c 100644 --- a/src/components/checkin/model.cpp +++ b/src/components/checkin/model.cpp @@ -71,6 +71,39 @@ bool CheckinModel::EncodeD2bCheckinRequest(const char *hw_uid, &_CheckinD2B); } + +bool CheckinModel::DecodeB2d(pb_istream_t *stream) { + // Zero-out the CheckinB2D message + memset(&_CheckinB2D, 0, sizeof(_CheckinB2D)); + // Decode the message + if (!pb_decode(stream, wippersnapper_checkin_CheckinB2D_fields, &_CheckinB2D)) + return false; + + // Attempt to get the payload and dispatch to the appropriate handler + if (_CheckinB2D.which_payload == wippersnapper_checkin_CheckinB2D_checkin_response_tag) { + // TODO: Refactor this code outwards to a handler func. + // Parse the CheckinResponse sub-message + _total_analog_pins = _CheckinB2D.payload.checkin_response.total_analog_pins; + _total_gpio_pins = _CheckinB2D.payload.checkin_response.total_gpio_pins; + _reference_voltage = _CheckinB2D.payload.checkin_response.reference_voltage; + // Okay, now let's look at component_adds[32] array + for (pb_size_t i = 0; i < _CheckinB2D.payload.checkin_response.component_adds_count; i++) { + // For now, just print out what component_adds we have + wippersnapper_checkin_ComponentAdd *compAdd = &_CheckinB2D.payload.checkin_response.component_adds[i]; + if (compAdd->which_payload == wippersnapper_checkin_ComponentAdd_digitalio_tag) { + // Process a DigitalIOAdd component add message + WS_DEBUG_PRINTLN("INFO: Found DigitalIOAdd component_add in CheckinResponse."); + WsV2.digital_io_controller->Handle_DigitalIO_Add(&compAdd->payload.digitalio); + } else { + // Component type not found + WS_DEBUG_PRINTLN("WARNING: Unknown component_add type in CheckinResponse!"); + } + } + } + + return true; +} + /*! @brief Fills and creates a CheckinRequest message @param hardware_uid diff --git a/src/components/checkin/model.h b/src/components/checkin/model.h index 36d34e38b..c58ce4dfe 100644 --- a/src/components/checkin/model.h +++ b/src/components/checkin/model.h @@ -16,6 +16,8 @@ #define WS_CHECKIN_MODEL_H #include "Wippersnapper_V2.h" +class Wippersnapper_V2; ///< Forward declaration + /*! @brief Provides an interface for creating, encoding, and parsing messages from checkin.proto. @@ -28,6 +30,9 @@ class CheckinModel { bool EncodeD2bCheckinRequest(const char *hw_uid, const char *fw_ver); wippersnapper_checkin_CheckinD2B *getD2bCheckinRequest(); + // BrokerToDevice Message Envelope + bool DecodeB2d(pb_istream_t *stream); + // Request Message void CreateCheckinRequest(const char *hardware_uid, const char *firmware_version); @@ -47,8 +52,8 @@ class CheckinModel { float getReferenceVoltage(); private: - wippersnapper_checkin_CheckinD2B - _CheckinD2B; ///< DeviceToBroker message envelope + wippersnapper_checkin_CheckinD2B _CheckinD2B; ///< DeviceToBroker message envelope + wippersnapper_checkin_CheckinB2D _CheckinB2D; ///< BrokerToDevice message envelope wippersnapper_checkin_CheckinRequest _CheckinRequest; wippersnapper_checkin_CheckinResponse _CheckinResponse; wippersnapper_checkin_CheckinResponse_Response _response; @@ -56,4 +61,5 @@ class CheckinModel { int32_t _total_analog_pins; float _reference_voltage; }; +extern Wippersnapper_V2 WsV2; ///< Wippersnapper V2 instance #endif // WS_CHECKIN_H \ No newline at end of file diff --git a/src/components/digitalIO/controller.cpp b/src/components/digitalIO/controller.cpp index 300f43acb..efc88fdbf 100644 --- a/src/components/digitalIO/controller.cpp +++ b/src/components/digitalIO/controller.cpp @@ -42,13 +42,66 @@ void DigitalIOController::SetMaxDigitalPins(uint8_t max_digital_pins) { _max_digitalio_pins = max_digital_pins; } + +bool DigitalIOController::Handle_DigitalIO_Add(wippersnapper_digitalio_DigitalIOAdd *msg_dio_add) { + // Early-out if we have reached the maximum number of digital pins + if (_digitalio_pins.size() >= _max_digitalio_pins) { + WS_DEBUG_PRINTLN("[digitalio] ERROR: Can not add new pin, all pins have " + "already been allocated!"); + return false; + } + + // Strip the D/A prefix off the pin name and convert to a uint8_t pin number + int pin_name = atoi(msg_dio_add->pin_name + 1); + + // Check if the provided pin is also the status LED pin + if (_dio_hardware->IsStatusLEDPin(pin_name)) + ReleaseStatusPixel(); + + // Deinit the pin if it's already in use + if (GetPinIdx(pin_name) != -1) + _dio_hardware->deinit(pin_name); + + // Attempt to configure the pin + if (!_dio_hardware->ConfigurePin( + pin_name, msg_dio_add->gpio_direction)) { + WS_DEBUG_PRINTLN( + "[digitalio] ERROR: Pin provided an invalid protobuf direction!"); + return false; + } + + ulong period = msg_dio_add->period; + // Create the digital pin and add it to the vector + DigitalIOPin new_pin = { + .pin_name = pin_name, + .pin_direction = msg_dio_add->gpio_direction, + .sample_mode = msg_dio_add->sample_mode, + .pin_value = msg_dio_add->value, + .pin_period = period * 1000, + .prv_pin_time = (millis() - 1) - period}; + _digitalio_pins.push_back(new_pin); + + // Print out the pin's details + WS_DEBUG_PRINTLN("[digitalio] Added new pin:"); + WS_DEBUG_PRINT("Pin Name: "); + WS_DEBUG_PRINTLN(new_pin.pin_name); + WS_DEBUG_PRINT("Period: "); + WS_DEBUG_PRINTLN(new_pin.pin_period); + WS_DEBUG_PRINT("Sample Mode: "); + WS_DEBUG_PRINTLN(new_pin.sample_mode); + WS_DEBUG_PRINT("Direction: "); + WS_DEBUG_PRINTLN(new_pin.pin_direction); + + return true; +} + /*! @brief Add a new digital pin to the controller @param stream The nanopb input stream. @return True if the digital pin was successfully added. */ -bool DigitalIOController::Handle_DigitalIO_Add(pb_istream_t *stream) { +/* bool DigitalIOController::Handle_DigitalIO_Add(pb_istream_t *stream) { // Early-out if we have reached the maximum number of digital pins if (_digitalio_pins.size() >= _max_digitalio_pins) { WS_DEBUG_PRINTLN("[digitalio] ERROR: Can not add new pin, all pins have " @@ -105,7 +158,7 @@ bool DigitalIOController::Handle_DigitalIO_Add(pb_istream_t *stream) { WS_DEBUG_PRINTLN(new_pin.pin_direction); return true; -} +} */ /*! @brief Removes a digital pin from the controller, if it exists diff --git a/src/components/digitalIO/controller.h b/src/components/digitalIO/controller.h index 2f2ace195..31b81a1b4 100644 --- a/src/components/digitalIO/controller.h +++ b/src/components/digitalIO/controller.h @@ -48,8 +48,10 @@ class DigitalIOController { public: DigitalIOController(); ~DigitalIOController(); + // NEW: Handler for wippersnapper_digitalio_DigitalIOAdd struct rather than stream + bool Handle_DigitalIO_Add(wippersnapper_digitalio_DigitalIOAdd *msg_dio_add); // Called by the cbDecodeBrokerToDevice router function - bool Handle_DigitalIO_Add(pb_istream_t *stream); + // bool Handle_DigitalIO_Add(pb_istream_t *stream); bool Handle_DigitalIO_Write(pb_istream_t *stream); bool Handle_DigitalIO_Remove(pb_istream_t *stream); From e7fc0b68ec64a2b0c737b0e669a9bc63a5955eac Mon Sep 17 00:00:00 2001 From: brentru Date: Thu, 13 Nov 2025 15:10:08 -0500 Subject: [PATCH 6/7] Finish handleCheckinResponse --- src/Wippersnapper_V2.cpp | 68 ++++++++++++++------------------ src/components/checkin/model.cpp | 41 ++++++++++++++++++- src/components/checkin/model.h | 2 + 3 files changed, 70 insertions(+), 41 deletions(-) diff --git a/src/Wippersnapper_V2.cpp b/src/Wippersnapper_V2.cpp index e0df0664c..394d597af 100644 --- a/src/Wippersnapper_V2.cpp +++ b/src/Wippersnapper_V2.cpp @@ -249,45 +249,6 @@ void Wippersnapper_V2::set_user_key() { WS_DEBUG_PRINTLN("ERROR: Please define a network interface!"); } -/*! - @brief Handles a Checkin Response message and initializes the - device's GPIO classes. - @param stream - Incoming data stream from buffer. - @returns True if Checkin Response decoded and parsed successfully, - False otherwise. -*/ -bool handleCheckinResponse(pb_istream_t *stream) { - // Decode the Checkin Response message - if (!WsV2.CheckInModel->DecodeCheckinResponse(stream)) { - WS_DEBUG_PRINTLN("ERROR: Unable to decode Checkin Response message"); - return false; - } - - // Parse the response message - WsV2.CheckInModel->ParseCheckinResponse(); - - // Validate the checkin response message - if (WsV2.CheckInModel->getCheckinResponse() != - wippersnapper_checkin_CheckinResponse_Response_RESPONSE_OK) { - WS_DEBUG_PRINTLN("ERROR: CheckinResponse not RESPONSE_OK, backing out!"); - return false; - } - - // Configure GPIO classes based on checkin response message - WsV2.digital_io_controller->SetMaxDigitalPins( - WsV2.CheckInModel->getTotalGPIOPins()); - - WsV2.analogio_controller->SetRefVoltage( - WsV2.CheckInModel->getReferenceVoltage()); - WsV2.analogio_controller->SetTotalAnalogPins( - WsV2.CheckInModel->getTotalAnalogPins()); - - // set glob flag so we don't keep the polling loop open - WsV2.got_checkin_response = true; - return true; -} - // Decoders // /*! @@ -1157,6 +1118,35 @@ void Wippersnapper_V2::PollCheckinResponse() { WS_DEBUG_PRINTLN("Completed checkin process!"); } +/*! + @brief Handles a Checkin Response message and initializes the + device's GPIO classes. + @param stream + Incoming data stream from buffer. + @returns True if Checkin Response decoded and parsed successfully, + False otherwise. +*/ +bool handleCheckinResponse(pb_istream_t *stream) { + // Decode and parse the BrokerToDevice message envelope + bool did_checkin = WsV2.CheckInModel->DecodeB2d(stream); + + // Publish checkincomplete back to broker after we process the response + if (!WsV2.CheckInModel->EncodeD2bCheckinComplete(did_checkin)) { + WS_DEBUG_PRINTLN("ERROR: Failed encoding Checkin Complete message!"); + return false; + } + + // Attempt to publish the Device to Broker message to the broker + if (!WsV2.PublishSignal(wippersnapper_signal_BrokerToDevice_checkin_tag, WsV2.CheckInModel->getD2bCheckinComplete())) { + WS_DEBUG_PRINTLN("[checkin] ERROR: Failed to publish CheckinRequest message!"); + return false; + } + + // Set flag so we don't keep the polling loop open + WsV2.got_checkin_response = true; + return true; +} + /*! @brief Pings the MQTT broker within the keepalive interval to keep the connection alive. Blinks the keepalive LED diff --git a/src/components/checkin/model.cpp b/src/components/checkin/model.cpp index 2204b386c..ed164d059 100644 --- a/src/components/checkin/model.cpp +++ b/src/components/checkin/model.cpp @@ -72,6 +72,33 @@ bool CheckinModel::EncodeD2bCheckinRequest(const char *hw_uid, } +bool CheckinModel::EncodeD2bCheckinComplete(bool success) { + // Zero-out the message envelope + memset(&_CheckinD2B, 0, sizeof(_CheckinD2B)); + // Set which_payload + _CheckinD2B.which_payload = + wippersnapper_checkin_CheckinD2B_checkin_complete_tag; + + // Obtain size of the CheckinD2B message + size_t CheckinD2BSz; + if (!pb_get_encoded_size( + &CheckinD2BSz, wippersnapper_checkin_CheckinD2B_fields, &_CheckinD2B)) + return false; + // Create a temporary buffer for holding the CheckinD2B message + uint8_t buf[CheckinD2BSz]; + // Create a stream that will write to buf + pb_ostream_t msg_stream = pb_ostream_from_buffer(buf, sizeof(buf)); + // Attempt to encode the message + return pb_encode(&msg_stream, wippersnapper_checkin_CheckinD2B_fields, + &_CheckinD2B); +} + + +wippersnapper_checkin_CheckinD2B*CheckinModel::getD2bCheckinComplete() { + return &_CheckinD2B; +} + + bool CheckinModel::DecodeB2d(pb_istream_t *stream) { // Zero-out the CheckinB2D message memset(&_CheckinB2D, 0, sizeof(_CheckinB2D)); @@ -81,11 +108,22 @@ bool CheckinModel::DecodeB2d(pb_istream_t *stream) { // Attempt to get the payload and dispatch to the appropriate handler if (_CheckinB2D.which_payload == wippersnapper_checkin_CheckinB2D_checkin_response_tag) { - // TODO: Refactor this code outwards to a handler func. + // Validate IO found the board's definition file + if (_CheckinB2D.payload.checkin_response.response != wippersnapper_checkin_CheckinResponse_Response_RESPONSE_OK) { + // TODO - Fix: raise and halt the app from continuing + WS_DEBUG_PRINTLN("ERROR: CheckinResponse indicates board not found!"); + return false; + } + + // TODO - Refactor // Parse the CheckinResponse sub-message _total_analog_pins = _CheckinB2D.payload.checkin_response.total_analog_pins; _total_gpio_pins = _CheckinB2D.payload.checkin_response.total_gpio_pins; _reference_voltage = _CheckinB2D.payload.checkin_response.reference_voltage; + WsV2.digital_io_controller->SetMaxDigitalPins(_total_gpio_pins); + WsV2.analogio_controller->SetRefVoltage(_reference_voltage); + WsV2.analogio_controller->SetTotalAnalogPins(_total_analog_pins); + // Okay, now let's look at component_adds[32] array for (pb_size_t i = 0; i < _CheckinB2D.payload.checkin_response.component_adds_count; i++) { // For now, just print out what component_adds we have @@ -100,7 +138,6 @@ bool CheckinModel::DecodeB2d(pb_istream_t *stream) { } } } - return true; } diff --git a/src/components/checkin/model.h b/src/components/checkin/model.h index c58ce4dfe..3dfebaf34 100644 --- a/src/components/checkin/model.h +++ b/src/components/checkin/model.h @@ -29,6 +29,8 @@ class CheckinModel { // DeviceToBroker Message Envelope bool EncodeD2bCheckinRequest(const char *hw_uid, const char *fw_ver); wippersnapper_checkin_CheckinD2B *getD2bCheckinRequest(); + bool EncodeD2bCheckinComplete(bool success); + wippersnapper_checkin_CheckinD2B *getD2bCheckinComplete(); // BrokerToDevice Message Envelope bool DecodeB2d(pb_istream_t *stream); From 41d3169c04bd2523f7de8d49e72f8b664bc748b2 Mon Sep 17 00:00:00 2001 From: brentru Date: Thu, 13 Nov 2025 15:21:38 -0500 Subject: [PATCH 7/7] Fix build: --- src/Wippersnapper_V2.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/Wippersnapper_V2.cpp b/src/Wippersnapper_V2.cpp index 394d597af..65a20016f 100644 --- a/src/Wippersnapper_V2.cpp +++ b/src/Wippersnapper_V2.cpp @@ -251,6 +251,9 @@ void Wippersnapper_V2::set_user_key() { // Decoders // +// Forward declaration +bool handleCheckinResponse(pb_istream_t *stream); + /*! @brief Decodes a BrokerToDevice message and executes the asscoiated callback. @@ -274,6 +277,7 @@ bool cbDecodeBrokerToDevice(pb_istream_t *stream, const pb_field_t *field, return false; } break; + } default: WS_DEBUG_PRINTLN("-> Unhandled B2D Message Type"); break;