Unused and untested peripheral endpoint updated to protobufs

esp32/include/peripherals/peripherals.h

@@ -1,15 +1,17 @@
 #pragma once
 
-#include <template/stateful_persistence.h>
+#include <template/stateful_persistence_pb.h>
 #include <template/stateful_service.h>
+#include <template/stateful_proto_endpoint.h>
 #include <utils/math_utils.h>
 #include <utils/timing.h>
 #include <filesystem.h>
 #include <features.h>
 #include <settings/peripherals_settings.h>
-#include <template/stateful_endpoint.h>
 #include <platform_shared/message.pb.h>
 
+#define PERIPHERAL_SETTINGS_FILE "/config/peripheralSettings.pb"
+
 #include <list>
 
 #include <NewPing.h>
@@ -64,10 +66,10 @@ class Peripherals : public StatefulService<PeripheralsConfiguration> {
 
     bool calibrateIMU();
 
-    StatefulHttpEndpoint<PeripheralsConfiguration> endpoint;
+    StatefulProtoEndpoint<PeripheralsConfiguration, api_PeripheralSettings> protoEndpoint;
 
   private:
-    FSPersistence<PeripheralsConfiguration> _persistence;
+    FSPersistencePB<PeripheralsConfiguration> _persistence;
 
     SemaphoreHandle_t _accessMutex;
     inline void beginTransaction() { xSemaphoreTakeRecursive(_accessMutex, portMAX_DELAY); }

esp32/include/settings/peripherals_settings.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include <vector>
-#include <ArduinoJson.h>
 #include <template/state_result.h>
-#include <string>
+#include <platform_shared/api.pb.h>
 
 /*
  * I2C software connection
@@ -18,33 +16,26 @@
 #define I2C_FREQUENCY 1000000UL
 #endif
 
-class PinConfig {
-  public:
-    int pin;
-    std::string mode;
-    std::string type;
-    std::string role;
+// Use proto types directly
+using PinConfig = api_PinConfig;
+using PeripheralsConfiguration = api_PeripheralSettings;
 
-    PinConfig(int p, std::string m, std::string t, std::string r) : pin(p), mode(m), type(t), role(r) {}
-};
+// Default factory settings
+inline PeripheralsConfiguration PeripheralsConfiguration_defaults() {
+    PeripheralsConfiguration settings = api_PeripheralSettings_init_zero;
+    settings.sda = SDA_PIN;
+    settings.scl = SCL_PIN;
+    settings.frequency = I2C_FREQUENCY;
+    settings.pins_count = 0;
+    return settings;
+}
 
-class PeripheralsConfiguration {
-  public:
-    int sda = SDA_PIN;
-    int scl = SCL_PIN;
-    long frequency = I2C_FREQUENCY;
-    std::vector<PinConfig> pins;
+// Proto read/update are identity functions since type is the same
+inline void PeripheralsConfiguration_read(const PeripheralsConfiguration& settings, PeripheralsConfiguration& proto) {
+    proto = settings;
+}
 
-    static void read(PeripheralsConfiguration &settings, JsonVariant &root) {
-        root["sda"] = settings.sda;
-        root["scl"] = settings.scl;
-        root["frequency"] = settings.frequency;
-    }
-
-    static StateUpdateResult update(JsonVariant &root, PeripheralsConfiguration &settings) {
-        settings.sda = root["sda"] | SDA_PIN;
-        settings.scl = root["scl"] | SCL_PIN;
-        settings.frequency = root["frequency"] | I2C_FREQUENCY;
-        return StateUpdateResult::CHANGED;
-    };
-};
+inline StateUpdateResult PeripheralsConfiguration_update(const PeripheralsConfiguration& proto, PeripheralsConfiguration& settings) {
+    settings = proto;
+    return StateUpdateResult::CHANGED;
+}

esp32/src/main.cpp

@@ -82,12 +82,12 @@ void setupServer() {
                              return apService.protoEndpoint.handleStateUpdate(request, protoReq);
                          });
     
-    // TODO: REMAKE TO PROTO - note: these are unused?
-    server.on("/api/peripherals", HTTP_GET,
-              [&](httpd_req_t *request) { return peripherals.endpoint.getState(request); });
-    server.on("/api/peripherals", HTTP_POST, [&](httpd_req_t *request, JsonVariant &json) {
-        return peripherals.endpoint.handleStateUpdate(request, json);
-    });
+    server.on("/api/peripherals/settings", HTTP_GET,
+              [&](httpd_req_t *request) { return peripherals.protoEndpoint.getState(request); });
+    server.onProto("/api/peripherals/settings", HTTP_POST,
+                   [&](httpd_req_t *request, api_Request *protoReq) {
+                       return peripherals.protoEndpoint.handleStateUpdate(request, protoReq);
+                   });
 
 #if FT_ENABLED(USE_MDNS)
     server.on("/api/mdns/settings", HTTP_GET, [&](httpd_req_t *request) { return mdnsService.protoEndpoint.getState(request); });

esp32/src/peripherals/peripherals.cpp

@@ -1,8 +1,12 @@
 #include <peripherals/peripherals.h>
 
 Peripherals::Peripherals()
-    : endpoint(PeripheralsConfiguration::read, PeripheralsConfiguration::update, this),
-      _persistence(PeripheralsConfiguration::read, PeripheralsConfiguration::update, this, DEVICE_CONFIG_FILE) {
+    : protoEndpoint(PeripheralsConfiguration_read, PeripheralsConfiguration_update, this,
+                    API_REQUEST_EXTRACTOR(peripheral_settings, api_PeripheralSettings),
+                    API_RESPONSE_ASSIGNER(peripheral_settings, api_PeripheralSettings)),
+      _persistence(PeripheralsConfiguration_read, PeripheralsConfiguration_update, this,
+                   PERIPHERAL_SETTINGS_FILE, api_PeripheralSettings_fields, api_PeripheralSettings_size,
+                   PeripheralsConfiguration_defaults()) {
     _accessMutex = xSemaphoreCreateMutex();
     addUpdateHandler([&](const std::string &originId) { updatePins(); }, false);
 }