Formatting, add remote calling to c library

examples/display/main.cpp

@@ -1,6 +1,6 @@
 #include <chrono>
-#include <iostream>
 #include <format>
+#include <iostream>
 #include <thread>
 
 #include "libcontrol.h"
@@ -16,15 +16,15 @@ int main() {
 
     std::cout << "Found " << controller->getModules().size() << " modules" << std::endl;
 
-    for (const auto& maybe_module : controller->getModules()) {
+    for (const auto &maybe_module : controller->getModules()) {
-        if (const auto& module = maybe_module.lock()) {
+        if (const auto &module = maybe_module.lock()) {
             std::cout << "Found module " << (int)module->get_device_id();
 
             if (module->get_type() == ModuleType_DISPLAY) {
-                module->actuate(std::format("BotChain \n\n\nModule ID: {}", module->get_device_id()));
+                module->actuate(
+                    std::format("BotChain \n\n\nModule ID: {}", module->get_device_id()));
             }
         }
-
     }
 
     return 0;

examples/rpc_call/CMakeLists.txt

@@ -9,7 +9,9 @@ find_package(libcontrol REQUIRED)
 find_package(spdlog REQUIRED)
 find_package(librpc REQUIRED)
 
-add_executable(RpcCallExample main.cpp)
+add_executable(RpcCallExample main.cpp flatbuffers/OTAPacketBuilder.cpp rpc/RemoteDebugging.cpp rpc/RemoteManagement.cpp)
+
+target_include_directories(RpcCallExample PUBLIC include)
 
 target_link_libraries(RpcCallExample
     PRIVATE

examples/rpc_call/flatbuffers/OTAPacketBuilder.cpp

@@ -0,0 +1,25 @@
+
+#include "flatbuffers/OTAPacketBuilder.h"
+#include "flatbuffers/SerializedMessage.h"
+
+namespace Flatbuffers {
+
+SerializedMessage OTAPacketBuilder::build_ota_packet(uint16_t packet_num,
+                                                     const std::vector<uint8_t> &packet) {
+    builder_.Clear();
+
+    const auto packet_vector = builder_.CreateVector(packet);
+
+    const auto message = Messaging::CreateOTAPacket(builder_, packet_num,
+                                                    static_cast<int>(packet.size()), packet_vector);
+
+    builder_.Finish(message);
+
+    return {builder_.GetBufferPointer(), builder_.GetSize()};
+}
+
+const Messaging::OTAPacket *OTAPacketBuilder::parse_ota_packet(const uint8_t *buffer) {
+    return flatbuffers::GetRoot<Messaging::OTAPacket>(buffer);
+}
+
+} // namespace Flatbuffers

examples/rpc_call/include/flatbuffers/OTAPacketBuilder.h

@@ -0,0 +1,28 @@
+
+
+#ifndef OTAPACKETBUILDER_H
+#define OTAPACKETBUILDER_H
+
+#include <vector>
+
+#include "flatbuffers/SerializedMessage.h"
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers_generated/OTAPacket_generated.h"
+
+namespace Flatbuffers {
+
+class OTAPacketBuilder {
+  public:
+    OTAPacketBuilder() : builder_(1024) {
+    }
+
+    SerializedMessage build_ota_packet(uint16_t packet_num, const std::vector<uint8_t> &packet);
+
+    static const Messaging::OTAPacket *parse_ota_packet(const uint8_t *buffer);
+
+  private:
+    flatbuffers::FlatBufferBuilder builder_;
+};
+} // namespace Flatbuffers
+
+#endif // OTAPACKETBUILDER_H

examples/rpc_call/include/flatbuffers/SerializedMessage.h

@@ -0,0 +1,15 @@
+//
+// Created by Johnathon Slightham on 2025-07-05.
+//
+
+#ifndef SERIALIZEDMESSAGE_H
+#define SERIALIZEDMESSAGE_H
+
+namespace Flatbuffers {
+struct SerializedMessage {
+    void *data;
+    size_t size;
+};
+} // namespace Flatbuffers
+
+#endif // SERIALIZEDMESSAGE_H

examples/rpc_call/include/flatbuffers_generated/OTAPacket_generated.h

@@ -0,0 +1,115 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_OTAPACKET_MESSAGING_H_
+#define FLATBUFFERS_GENERATED_OTAPACKET_MESSAGING_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+// static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+//               FLATBUFFERS_VERSION_MINOR == 2 &&
+//               FLATBUFFERS_VERSION_REVISION == 10,
+//              "Non-compatible flatbuffers version included");
+
+namespace Messaging {
+
+struct OTAPacket;
+struct OTAPacketBuilder;
+
+struct OTAPacket FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+    typedef OTAPacketBuilder Builder;
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+        VT_SEQUENCE_NUMBER = 4,
+        VT_LENGTH = 6,
+        VT_PAYLOAD = 8
+    };
+    uint16_t sequence_number() const {
+        return GetField<uint16_t>(VT_SEQUENCE_NUMBER, 0);
+    }
+    uint16_t length() const {
+        return GetField<uint16_t>(VT_LENGTH, 0);
+    }
+    const ::flatbuffers::Vector<uint8_t> *payload() const {
+        return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD);
+    }
+    bool Verify(::flatbuffers::Verifier &verifier) const {
+        return VerifyTableStart(verifier) &&
+               VerifyField<uint16_t>(verifier, VT_SEQUENCE_NUMBER, 2) &&
+               VerifyField<uint16_t>(verifier, VT_LENGTH, 2) &&
+               VerifyOffset(verifier, VT_PAYLOAD) && verifier.VerifyVector(payload()) &&
+               verifier.EndTable();
+    }
+};
+
+struct OTAPacketBuilder {
+    typedef OTAPacket Table;
+    ::flatbuffers::FlatBufferBuilder &fbb_;
+    ::flatbuffers::uoffset_t start_;
+    void add_sequence_number(uint16_t sequence_number) {
+        fbb_.AddElement<uint16_t>(OTAPacket::VT_SEQUENCE_NUMBER, sequence_number, 0);
+    }
+    void add_length(uint16_t length) {
+        fbb_.AddElement<uint16_t>(OTAPacket::VT_LENGTH, length, 0);
+    }
+    void add_payload(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload) {
+        fbb_.AddOffset(OTAPacket::VT_PAYLOAD, payload);
+    }
+    explicit OTAPacketBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+        start_ = fbb_.StartTable();
+    }
+    ::flatbuffers::Offset<OTAPacket> Finish() {
+        const auto end = fbb_.EndTable(start_);
+        auto o = ::flatbuffers::Offset<OTAPacket>(end);
+        return o;
+    }
+};
+
+inline ::flatbuffers::Offset<OTAPacket>
+CreateOTAPacket(::flatbuffers::FlatBufferBuilder &_fbb, uint16_t sequence_number = 0,
+                uint16_t length = 0,
+                ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload = 0) {
+    OTAPacketBuilder builder_(_fbb);
+    builder_.add_payload(payload);
+    builder_.add_length(length);
+    builder_.add_sequence_number(sequence_number);
+    return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<OTAPacket>
+CreateOTAPacketDirect(::flatbuffers::FlatBufferBuilder &_fbb, uint16_t sequence_number = 0,
+                      uint16_t length = 0, const std::vector<uint8_t> *payload = nullptr) {
+    auto payload__ = payload ? _fbb.CreateVector<uint8_t>(*payload) : 0;
+    return Messaging::CreateOTAPacket(_fbb, sequence_number, length, payload__);
+}
+
+inline const Messaging::OTAPacket *GetOTAPacket(const void *buf) {
+    return ::flatbuffers::GetRoot<Messaging::OTAPacket>(buf);
+}
+
+inline const Messaging::OTAPacket *GetSizePrefixedOTAPacket(const void *buf) {
+    return ::flatbuffers::GetSizePrefixedRoot<Messaging::OTAPacket>(buf);
+}
+
+inline bool VerifyOTAPacketBuffer(::flatbuffers::Verifier &verifier) {
+    return verifier.VerifyBuffer<Messaging::OTAPacket>(nullptr);
+}
+
+inline bool VerifySizePrefixedOTAPacketBuffer(::flatbuffers::Verifier &verifier) {
+    return verifier.VerifySizePrefixedBuffer<Messaging::OTAPacket>(nullptr);
+}
+
+inline void FinishOTAPacketBuffer(::flatbuffers::FlatBufferBuilder &fbb,
+                                  ::flatbuffers::Offset<Messaging::OTAPacket> root) {
+    fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedOTAPacketBuffer(::flatbuffers::FlatBufferBuilder &fbb,
+                                              ::flatbuffers::Offset<Messaging::OTAPacket> root) {
+    fbb.FinishSizePrefixed(root);
+}
+
+} // namespace Messaging
+
+#endif // FLATBUFFERS_GENERATED_OTAPACKET_MESSAGING_H_

examples/rpc_call/include/rpc/RemoteDebugging.h

@@ -0,0 +1,24 @@
+//
+// Created by Johnathon Slightham on 2026-02-16.
+//
+
+#ifndef NEW_DEV_TOOLS_REMOTEDEBUGGING_H
+#define NEW_DEV_TOOLS_REMOTEDEBUGGING_H
+
+#include <cstdint>
+#include <string>
+
+#include "libcontrol.h"
+
+class RemoteDebugging {
+  public:
+    RemoteDebugging(std::shared_ptr<RobotController> controller) : m_robot_controller(controller) {
+    }
+    std::string get_task_manager(uint8_t module_id);
+    std::string get_logs(uint8_t module_id);
+
+  private:
+    std::shared_ptr<RobotController> m_robot_controller;
+};
+
+#endif //NEW_DEV_TOOLS_REMOTEDEBUGGING_H

examples/rpc_call/include/rpc/RemoteManagement.h

@@ -0,0 +1,38 @@
+//
+// Created by Johnathon Slightham on 2026-02-16.
+//
+
+#ifndef REMOTEMANAGEMENT_H
+#define REMOTEMANAGEMENT_H
+
+#include <cstdint>
+#include <fstream>
+#include <memory>
+
+#include "flatbuffers/OTAPacketBuilder.h"
+#include "libcontrol.h"
+
+class RemoteManagement {
+  public:
+    RemoteManagement(uint8_t module_id, const std::string &path,
+                     std::shared_ptr<RobotController> controller)
+        : m_module_id(module_id), m_file(path, std::ios::binary),
+          m_builder(std::make_unique<Flatbuffers::OTAPacketBuilder>()),
+          m_robot_controller(controller) {
+    }
+    bool perform_ota();
+    void restart();
+
+  private:
+    bool start_ota();
+    bool write_ota(std::vector<uint8_t> &transmit_buffer);
+    bool ota_end();
+
+    uint16_t m_sequence_num = 0;
+    uint8_t m_module_id;
+    std::ifstream m_file;
+    std::unique_ptr<Flatbuffers::OTAPacketBuilder> m_builder;
+    std::shared_ptr<RobotController> m_robot_controller;
+};
+
+#endif // REMOTEMANAGEMENT_H

examples/rpc_call/main.cpp

@@ -7,34 +7,42 @@
 #include <vector>
 
 #include "libcontrol.h"
+#include "rpc/RemoteManagement.h"
 
 int main() {
 
-  const auto messaging_interface = std::make_unique<MessagingInterface>();
+    // const auto messaging_interface = std::make_unique<MessagingInterface>();
 
-  const auto modules =
+    // const auto modules = messaging_interface->find_connected_modules(std::chrono::seconds(3));
-      messaging_interface->find_connected_modules(std::chrono::seconds(3));
 
-  std::cout << "Found " << modules.size() << " modules" << std::endl;
+    // std::cout << "Found " << modules.size() << " modules" << std::endl;
 
-  for (const auto module : modules) {
+    // for (const auto module : modules) {
-    std::cout << "Found ID " << (int)module << std::endl;
+    //     std::cout << "Found ID " << (int)module << std::endl;
-  }
+    // }
 
-  const auto function_tag = 100;
+    const auto robot_controller = std::make_shared<RobotController>();
-  const auto module = 98;
+    robot_controller->fetchDirectlyConnectedModules(true);
-  std::string msg = "Hello world!";
+    std::this_thread::sleep_for(std::chrono::seconds(5));
-  std::vector<uint8_t> parameters(msg.begin(), msg.end());
-  auto maybe_return_value =
-      messaging_interface->remote_call(function_tag, module, parameters);
 
-  if (maybe_return_value) {
+    // const auto function_tag = 3;
-    auto return_value = std::move(*maybe_return_value);
+    // const auto module = 99;
-    std::cout << "Got return value " << (char *)return_value->data()
+    // std::string msg = "Hello world!";
-              << std::endl;
+    // std::vector<uint8_t> parameters(msg.begin(), msg.end());
-  } else {
+    // auto maybe_return_value = messaging_interface->remote_call(function_tag, module, parameters);
-    std::cout << "Function call time out" << std::endl;
+
-  }
+    // if (maybe_return_value) {
+    //     auto return_value = std::move(*maybe_return_value);
+    //     std::cout << "Got return value " << (char *)return_value->data() << std::endl;
+    // } else {
+    //     std::cout << "Function call time out" << std::endl;
+    // }
+    //
+
+    std::string filename =
+        "/Users/jslightham/Documents/Classes/capstone/firmware/build/firmware.bin";
+    const auto rm = std::make_unique<RemoteManagement>(99, filename, robot_controller);
+    rm->perform_ota();
 
     return 0;
 }

examples/rpc_call/rpc/RemoteDebugging.cpp

@@ -0,0 +1,23 @@
+//
+// Created by Johnathon Slightham on 2026-02-16.
+//
+
+#include "rpc/RemoteDebugging.h"
+
+std::string RemoteDebugging::get_task_manager(uint8_t module_id) {
+    const auto maybe = m_robot_controller->remote_call(2, module_id, {});
+    if (maybe) {
+        std::string str((*maybe)->begin(), (*maybe)->end());
+        return str;
+    }
+    return "";
+}
+
+std::string RemoteDebugging::get_logs(uint8_t module_id) {
+    const auto maybe = m_robot_controller->remote_call(3, module_id, {});
+    if (maybe) {
+        std::string str((*maybe)->begin(), (*maybe)->end());
+        return str;
+    }
+    return "";
+}

examples/rpc_call/rpc/RemoteManagement.cpp

@@ -0,0 +1,98 @@
+//
+// Created by Johnathon Slightham on 2026-02-16.
+//
+
+#include <fstream>
+#include <iostream>
+
+#include "rpc/RemoteManagement.h"
+
+#define MAX_PACKET_TX_ATTEMPTS 5
+#define OTA_CHUNK_SIZE 1024
+
+bool RemoteManagement::perform_ota() {
+    if (!m_file) {
+        return false;
+    }
+
+    if (!start_ota()) {
+        // std::cout << "Fail to start OTA update" << std::endl;
+        return false;
+    }
+
+    m_file.seekg(0, std::ios::end);
+    std::streamsize total_size = m_file.tellg();
+    m_file.seekg(0, std::ios::beg);
+    // std::cout << "Total number of chunks: " << total_size/OTA_CHUNK_SIZE << std::endl;
+
+    while (m_file) {
+        // std::cout << "Top of transmit " << m_sequence_num << std::endl;
+
+        std::vector<uint8_t> buffer(OTA_CHUNK_SIZE);
+        m_file.read(reinterpret_cast<char *>(buffer.data()), buffer.size());
+        std::streamsize bytes_read = m_file.gcount();
+
+        if (bytes_read <= 0) {
+            break;
+        }
+
+        if (m_sequence_num == 1 && buffer[0] != 0xE9) {
+            // std::cout << "First byte of firmware must be 0xE9" << std::endl;
+            return false;
+        }
+
+        // buffer.resize(bytes_read);
+        if (!write_ota(buffer)) {
+            // std::cout << "Failed to write" << std::endl;
+            return false;
+        }
+    }
+
+    ota_end();
+    restart();
+
+    return true;
+}
+
+void RemoteManagement::restart() {
+    // Will never return since the module will shutdown
+    m_robot_controller->remote_call(7, m_module_id, {});
+}
+
+bool RemoteManagement::start_ota() {
+    // std::cout << "Starting OTA" << std::endl;
+    const auto maybe = m_robot_controller->remote_call(4, m_module_id, {});
+    if (maybe) {
+        // std::cout << "Got valid response" << std::endl;
+        m_sequence_num = 1;
+        return (*maybe)->at(0) > 0;
+    }
+    return false;
+}
+
+bool RemoteManagement::write_ota(std::vector<uint8_t> &transmit_buffer) {
+    // std::cout << "Write OTA " << std::endl;
+    const auto [ota_packet, packet_size] =
+        m_builder->build_ota_packet(m_sequence_num, transmit_buffer);
+    std::vector<uint8_t> vec((uint8_t *)ota_packet, (uint8_t *)ota_packet + packet_size);
+    int attempts = 0;
+    while (attempts < MAX_PACKET_TX_ATTEMPTS) {
+        const auto maybe = m_robot_controller->remote_call(5, m_module_id, vec);
+        if (maybe && (*maybe)->at(0) > 0) {
+            // std::cout << "Success writing OTA" << std::endl;
+            m_sequence_num++;
+            return true;
+        }
+        attempts++;
+    }
+    return false;
+}
+
+bool RemoteManagement::ota_end() {
+    const auto maybe = m_robot_controller->remote_call(6, m_module_id, {});
+    if (maybe) {
+        m_sequence_num = 0;
+        return (*maybe)->at(0) > 0;
+    }
+    return false;
+}

include/Hub.h

@@ -10,14 +10,13 @@
 
 class Hub final : public Module {
 
-public:
+  public:
     explicit Hub(uint8_t device_id) : Module(device_id) {};
 
-  Hub(uint8_t device_id, ModuleType module_type)
+    Hub(uint8_t device_id, ModuleType module_type) : Module(device_id, module_type) {};
-      : Module(device_id, module_type) {};
 
-  Hub(uint8_t device_id, ModuleType module_type,
+    Hub(uint8_t device_id, ModuleType module_type, Messaging::ConnectionType connection_type,
-      Messaging::ConnectionType connection_type, uint8_t leader)
+        uint8_t leader)
         : Module(device_id, module_type, connection_type, leader) {};
 
     double get_position() override;

include/Module.h

@@ -20,16 +20,16 @@ struct neighbour {
 };
 
 class Module {
-public:
+  public:
     explicit Module(uint8_t device_id) : m_device_id(device_id) {};
 
     Module(uint8_t device_id, ModuleType module_type)
         : m_device_id(device_id), m_module_type(module_type) {};
 
-  Module(uint8_t device_id, ModuleType module_type,
+    Module(uint8_t device_id, ModuleType module_type, Messaging::ConnectionType connection_type,
-         Messaging::ConnectionType connection_type, uint8_t leader)
+           uint8_t leader)
-      : m_device_id(device_id), m_module_type(module_type),
+        : m_device_id(device_id), m_module_type(module_type), m_connection_type(connection_type),
-        m_connection_type(connection_type), m_leader(leader) {};
+          m_leader(leader) {};
 
     std::vector<neighbour> get_neighbours();
 
@@ -55,7 +55,7 @@ public:
     virtual std::vector<uint8_t> get_actuation_message() = 0;
     virtual void update_sensor_data(const Flatbuffers::sensor_value &value) = 0;
 
-private:
+  private:
     uint8_t m_device_id;
     ModuleType m_module_type;
     Messaging::ConnectionType m_connection_type;

include/ModuleFactory.h

@@ -5,7 +5,7 @@
 #include "flatbuffers_generated/RobotModule_generated.h"
 
 class ModuleFactory {
-public:
+  public:
     static std::shared_ptr<Module>
     createModule(uint8_t device_id, ModuleType type,
                  std::shared_ptr<MessagingInterface> &messaging_interface);

include/actuators/Actuator.h

@@ -9,20 +9,19 @@
 #include "flatbuffers_generated/TopologyMessage_generated.h"
 
 class Actuator : public Module {
-public:
+  public:
     explicit Actuator(uint8_t device_id) : Module(device_id) {};
 
-  Actuator(uint8_t device_id, ModuleType module_type)
+    Actuator(uint8_t device_id, ModuleType module_type) : Module(device_id, module_type) {};
-      : Module(device_id, module_type) {};
 
-  Actuator(uint8_t device_id, ModuleType module_type,
+    Actuator(uint8_t device_id, ModuleType module_type, Messaging::ConnectionType connection_type,
-           Messaging::ConnectionType connection_type, uint8_t leader)
+             uint8_t leader)
         : Module(device_id, module_type, connection_type, leader) {};
 
-protected:
+  protected:
     virtual std::vector<uint8_t> get_actuation_message() = 0;
 
-private:
+  private:
     [[noreturn]] void actuator_tx_loop();
 };
 

include/actuators/BoundedPositionalActuator1D.h

@@ -13,14 +13,13 @@
 
 class BoundedPositionalActuator1D : public Actuator {
 
-public:
+  public:
-  BoundedPositionalActuator1D(uint8_t device_id, ModuleType type,
+    BoundedPositionalActuator1D(uint8_t device_id, ModuleType type, double max_value,
-                              double max_value, double min_value,
+                                double min_value, double initial_position)
-                              double initial_position)
+        : Actuator(device_id, type), m_target_position(initial_position), m_max_value(max_value),
-      : Actuator(device_id, type), m_target_position(initial_position),
+          m_min_value(min_value),
-        m_max_value(max_value), m_min_value(min_value),
+          acm_builder(std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {
-        acm_builder(
+    }
-            std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {}
 
     double get_position() override;
     std::string get_text() override; // no-op
@@ -31,7 +30,7 @@ public:
     std::vector<uint8_t> get_actuation_message() override;
     void update_sensor_data(const Flatbuffers::sensor_value &value) override;
 
-private:
+  private:
     double m_current_position = 0;
     double m_target_position;
     double m_max_value;

include/actuators/OledActuator.h

@@ -13,11 +13,11 @@
 
 class OledActuator : public Actuator {
 
-public:
+  public:
     OledActuator(uint8_t device_id, ModuleType type)
         : Actuator(device_id, type),
-        m_text_message_builder(
+          m_text_message_builder(std::make_unique<Flatbuffers::TextControlMessageBuilder>()) {
-            std::make_unique<Flatbuffers::TextControlMessageBuilder>()) {}
+    }
 
     double get_position() override;
     std::string get_text() override;
@@ -28,11 +28,10 @@ public:
     std::vector<uint8_t> get_actuation_message() override;
     void update_sensor_data(const Flatbuffers::sensor_value &value) override;
 
-private:
+  private:
     std::string m_current_text = "";
     std::string m_target_text = "";
-  std::unique_ptr<Flatbuffers::TextControlMessageBuilder>
+    std::unique_ptr<Flatbuffers::TextControlMessageBuilder> m_text_message_builder;
-      m_text_message_builder;
 };
 
 #endif // CONTROL_OLEDACTUATOR_H

include/actuators/PositionalActuator1D.h

@@ -13,11 +13,10 @@
 
 class PositionalActuator1D final : public Actuator {
 
-public:
+  public:
     PositionalActuator1D(uint8_t device_id, ModuleType type)
         : Actuator(device_id, type),
-        m_acm_builder(
+          m_acm_builder(std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {};
-            std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {};
 
     double get_position() override;
     std::string get_text() override; // no-op
@@ -28,7 +27,7 @@ public:
     std::vector<uint8_t> get_actuation_message() override;
     void update_sensor_data(const Flatbuffers::sensor_value &value) override;
 
-private:
+  private:
     void update_loop();
     double m_target_position = 0;
     double m_current_position = 0;

include/flatbuffers/AngleControlMessageBuilder.h

@@ -14,14 +14,14 @@
 
 namespace Flatbuffers {
 class AngleControlMessageBuilder {
-public:
+  public:
-  AngleControlMessageBuilder() : builder_(256) {}
+    AngleControlMessageBuilder() : builder_(256) {
+    }
 
     SerializedMessage build_angle_control_message(int16_t angle);
-  static const Messaging::AngleControlMessage *
+    static const Messaging::AngleControlMessage *parse_angle_control_message(const uint8_t *buffer);
-  parse_angle_control_message(const uint8_t *buffer);
 
-private:
+  private:
     flatbuffers::FlatBufferBuilder builder_;
 };
 } // namespace Flatbuffers

include/flatbuffers/RobotConfigurationBuilder.h

@@ -26,17 +26,18 @@ struct ModuleConnectionInstance {
 };
 
 class RobotConfigurationBuilder {
-public:
+  public:
-  RobotConfigurationBuilder() : builder_(1024) {}
+    RobotConfigurationBuilder() : builder_(1024) {
+    }
 
-  SerializedMessage build_robot_configuration(
+    SerializedMessage
-      const std::vector<ModuleInstance> &modules,
+    build_robot_configuration(const std::vector<ModuleInstance> &modules,
                               const std::vector<ModuleConnectionInstance> &connections);
 
     static const Frontend::RobotConfiguration *
     parse_robot_configuration(const std::uint8_t *buffer);
 
-private:
+  private:
     flatbuffers::FlatBufferBuilder builder_;
 };
 } // namespace Flatbuffers

include/flatbuffers/SensorMessageBuilder.h

@@ -27,15 +27,14 @@ struct current_text {
 typedef std::variant<target_angle, current_angle, current_text> sensor_value;
 
 class SensorMessageBuilder {
-public:
+  public:
-  SensorMessageBuilder() : builder_(1024) {}
+    SensorMessageBuilder() : builder_(1024) {
+    }
 
-  static const Messaging::SensorMessage *
+    static const Messaging::SensorMessage *parse_sensor_message(const std::uint8_t *buffer);
-  parse_sensor_message(const std::uint8_t *buffer);
 
     template <typename T>
-  static std::optional<sensor_value>
+    static std::optional<sensor_value> build_sensor_value(Messaging::SensorValue type, T value) {
-  build_sensor_value(Messaging::SensorValue type, T value) {
         switch (type) {
         case Messaging::SensorValue_TargetAngle: {
             const Messaging::TargetAngle *target =
@@ -57,7 +56,7 @@ public:
         }
     }
 
-private:
+  private:
     flatbuffers::FlatBufferBuilder builder_;
 };
 } // namespace Flatbuffers

include/flatbuffers/TextControlMessageBuilder.h

@@ -14,12 +14,13 @@
 
 namespace Flatbuffers {
 class TextControlMessageBuilder {
-public:
+  public:
-  TextControlMessageBuilder() : builder_(256) {}
+    TextControlMessageBuilder() : builder_(256) {
+    }
 
     SerializedMessage build_text_control_message(std::string &t);
 
-private:
+  private:
     flatbuffers::FlatBufferBuilder builder_;
 };
 } // namespace Flatbuffers

include/flatbuffers/TopologyMessageBuilder.h

@@ -12,20 +12,19 @@
 
 namespace Flatbuffers {
 class TopologyMessageBuilder {
-public:
+  public:
-  TopologyMessageBuilder() : builder_(1024) {}
+    TopologyMessageBuilder() : builder_(1024) {
+    }
 
-  SerializedMessage
+    SerializedMessage build_topology_message(uint8_t module_id, ModuleType module_type,
-  build_topology_message(uint8_t module_id, ModuleType module_type,
                                              const std::vector<uint8_t> &channel_to_module,
                                              const std::vector<int8_t> &orientation_to_module);
 
-  static const Messaging::TopologyMessage *
+    static const Messaging::TopologyMessage *parse_topology_message(const uint8_t *buffer);
-  parse_topology_message(const uint8_t *buffer);
 
     static bool is_valid_topology_message(const uint8_t *buffer, size_t size);
 
-private:
+  private:
     flatbuffers::FlatBufferBuilder builder_;
 };
 } // namespace Flatbuffers

include/flatbuffers_generated/AngleControlMessage_generated.h

@@ -17,16 +17,15 @@ namespace Messaging {
 struct AngleControlMessage;
 struct AngleControlMessageBuilder;
 
-struct AngleControlMessage FLATBUFFERS_FINAL_CLASS
+struct AngleControlMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-    : private ::flatbuffers::Table {
     typedef AngleControlMessageBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ANGLE = 4 };
-    VT_ANGLE = 4
+    int16_t angle() const {
-  };
+        return GetField<int16_t>(VT_ANGLE, 0);
-  int16_t angle() const { return GetField<int16_t>(VT_ANGLE, 0); }
+    }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<int16_t>(verifier, VT_ANGLE, 2) &&
-           VerifyField<int16_t>(verifier, VT_ANGLE, 2) && verifier.EndTable();
+               verifier.EndTable();
     }
 };
 
@@ -37,8 +36,7 @@ struct AngleControlMessageBuilder {
     void add_angle(int16_t angle) {
         fbb_.AddElement<int16_t>(AngleControlMessage::VT_ANGLE, angle, 0);
     }
-  explicit AngleControlMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit AngleControlMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<AngleControlMessage> Finish() {
@@ -49,36 +47,30 @@ struct AngleControlMessageBuilder {
 };
 
 inline ::flatbuffers::Offset<AngleControlMessage>
-CreateAngleControlMessage(::flatbuffers::FlatBufferBuilder &_fbb,
+CreateAngleControlMessage(::flatbuffers::FlatBufferBuilder &_fbb, int16_t angle = 0) {
-                          int16_t angle = 0) {
     AngleControlMessageBuilder builder_(_fbb);
     builder_.add_angle(angle);
     return builder_.Finish();
 }
 
-inline const Messaging::AngleControlMessage *
+inline const Messaging::AngleControlMessage *GetAngleControlMessage(const void *buf) {
-GetAngleControlMessage(const void *buf) {
     return ::flatbuffers::GetRoot<Messaging::AngleControlMessage>(buf);
 }
 
-inline const Messaging::AngleControlMessage *
+inline const Messaging::AngleControlMessage *GetSizePrefixedAngleControlMessage(const void *buf) {
-GetSizePrefixedAngleControlMessage(const void *buf) {
+    return ::flatbuffers::GetSizePrefixedRoot<Messaging::AngleControlMessage>(buf);
-  return ::flatbuffers::GetSizePrefixedRoot<Messaging::AngleControlMessage>(
-      buf);
 }
 
 inline bool VerifyAngleControlMessageBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifyBuffer<Messaging::AngleControlMessage>(nullptr);
 }
 
-inline bool
+inline bool VerifySizePrefixedAngleControlMessageBuffer(::flatbuffers::Verifier &verifier) {
-VerifySizePrefixedAngleControlMessageBuffer(::flatbuffers::Verifier &verifier) {
+    return verifier.VerifySizePrefixedBuffer<Messaging::AngleControlMessage>(nullptr);
-  return verifier.VerifySizePrefixedBuffer<Messaging::AngleControlMessage>(
-      nullptr);
 }
 
-inline void FinishAngleControlMessageBuffer(
+inline void
-    ::flatbuffers::FlatBufferBuilder &fbb,
+FinishAngleControlMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                 ::flatbuffers::Offset<Messaging::AngleControlMessage> root) {
     fbb.Finish(root);
 }

include/flatbuffers_generated/RobotConfiguration_generated.h

@@ -34,20 +34,24 @@ struct ModuleConnection FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     uint8_t from_module_id() const {
         return GetField<uint8_t>(VT_FROM_MODULE_ID, 0);
     }
-  uint8_t to_module_id() const { return GetField<uint8_t>(VT_TO_MODULE_ID, 0); }
+    uint8_t to_module_id() const {
-  uint8_t from_socket() const { return GetField<uint8_t>(VT_FROM_SOCKET, 0); }
+        return GetField<uint8_t>(VT_TO_MODULE_ID, 0);
-  uint8_t to_socket() const { return GetField<uint8_t>(VT_TO_SOCKET, 0); }
+    }
+    uint8_t from_socket() const {
+        return GetField<uint8_t>(VT_FROM_SOCKET, 0);
+    }
+    uint8_t to_socket() const {
+        return GetField<uint8_t>(VT_TO_SOCKET, 0);
+    }
     Orientation orientation() const {
         return static_cast<Orientation>(GetField<int8_t>(VT_ORIENTATION, 0));
     }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_FROM_MODULE_ID, 1) &&
-           VerifyField<uint8_t>(verifier, VT_FROM_MODULE_ID, 1) &&
                VerifyField<uint8_t>(verifier, VT_TO_MODULE_ID, 1) &&
                VerifyField<uint8_t>(verifier, VT_FROM_SOCKET, 1) &&
                VerifyField<uint8_t>(verifier, VT_TO_SOCKET, 1) &&
-           VerifyField<int8_t>(verifier, VT_ORIENTATION, 1) &&
+               VerifyField<int8_t>(verifier, VT_ORIENTATION, 1) && verifier.EndTable();
-           verifier.EndTable();
     }
 };
 
@@ -56,12 +60,10 @@ struct ModuleConnectionBuilder {
     ::flatbuffers::FlatBufferBuilder &fbb_;
     ::flatbuffers::uoffset_t start_;
     void add_from_module_id(uint8_t from_module_id) {
-    fbb_.AddElement<uint8_t>(ModuleConnection::VT_FROM_MODULE_ID,
+        fbb_.AddElement<uint8_t>(ModuleConnection::VT_FROM_MODULE_ID, from_module_id, 0);
-                             from_module_id, 0);
     }
     void add_to_module_id(uint8_t to_module_id) {
-    fbb_.AddElement<uint8_t>(ModuleConnection::VT_TO_MODULE_ID, to_module_id,
+        fbb_.AddElement<uint8_t>(ModuleConnection::VT_TO_MODULE_ID, to_module_id, 0);
-                             0);
     }
     void add_from_socket(uint8_t from_socket) {
         fbb_.AddElement<uint8_t>(ModuleConnection::VT_FROM_SOCKET, from_socket, 0);
@@ -70,11 +72,10 @@ struct ModuleConnectionBuilder {
         fbb_.AddElement<uint8_t>(ModuleConnection::VT_TO_SOCKET, to_socket, 0);
     }
     void add_orientation(Orientation orientation) {
-    fbb_.AddElement<int8_t>(ModuleConnection::VT_ORIENTATION,
+        fbb_.AddElement<int8_t>(ModuleConnection::VT_ORIENTATION, static_cast<int8_t>(orientation),
-                            static_cast<int8_t>(orientation), 0);
+                                0);
     }
-  explicit ModuleConnectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit ModuleConnectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<ModuleConnection> Finish() {
@@ -85,9 +86,8 @@ struct ModuleConnectionBuilder {
 };
 
 inline ::flatbuffers::Offset<ModuleConnection>
-CreateModuleConnection(::flatbuffers::FlatBufferBuilder &_fbb,
+CreateModuleConnection(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t from_module_id = 0,
-                       uint8_t from_module_id = 0, uint8_t to_module_id = 0,
+                       uint8_t to_module_id = 0, uint8_t from_socket = 0, uint8_t to_socket = 0,
-                       uint8_t from_socket = 0, uint8_t to_socket = 0,
                        Orientation orientation = Orientation_Deg0) {
     ModuleConnectionBuilder builder_(_fbb);
     builder_.add_orientation(orientation);
@@ -98,31 +98,26 @@ CreateModuleConnection(::flatbuffers::FlatBufferBuilder &_fbb,
     return builder_.Finish();
 }
 
-struct RobotConfiguration FLATBUFFERS_FINAL_CLASS
+struct RobotConfiguration FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-    : private ::flatbuffers::Table {
     typedef RobotConfigurationBuilder Builder;
     enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
         VT_MODULES = 4,
         VT_CONNECTIONS = 6
     };
-  const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *
+    const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *modules() const {
-  modules() const {
+        return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *>(
-    return GetPointer<
-        const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *>(
             VT_MODULES);
     }
-  const ::flatbuffers::Vector<
+    const ::flatbuffers::Vector<::flatbuffers::Offset<Frontend::ModuleConnection>> *
-      ::flatbuffers::Offset<Frontend::ModuleConnection>> *
     connections() const {
-    return GetPointer<const ::flatbuffers::Vector<
+        return GetPointer<
-        ::flatbuffers::Offset<Frontend::ModuleConnection>> *>(VT_CONNECTIONS);
+            const ::flatbuffers::Vector<::flatbuffers::Offset<Frontend::ModuleConnection>> *>(
+            VT_CONNECTIONS);
     }
     bool Verify(::flatbuffers::Verifier &verifier) const {
         return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MODULES) &&
-           verifier.VerifyVector(modules()) &&
+               verifier.VerifyVector(modules()) && verifier.VerifyVectorOfTables(modules()) &&
-           verifier.VerifyVectorOfTables(modules()) &&
+               VerifyOffset(verifier, VT_CONNECTIONS) && verifier.VerifyVector(connections()) &&
-           VerifyOffset(verifier, VT_CONNECTIONS) &&
-           verifier.VerifyVector(connections()) &&
                verifier.VerifyVectorOfTables(connections()) && verifier.EndTable();
     }
 };
@@ -131,18 +126,16 @@ struct RobotConfigurationBuilder {
     typedef RobotConfiguration Table;
     ::flatbuffers::FlatBufferBuilder &fbb_;
     ::flatbuffers::uoffset_t start_;
-  void add_modules(::flatbuffers::Offset<
+    void add_modules(
-                   ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>>
+        ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>> modules) {
-                       modules) {
         fbb_.AddOffset(RobotConfiguration::VT_MODULES, modules);
     }
-  void add_connections(::flatbuffers::Offset<::flatbuffers::Vector<
+    void add_connections(::flatbuffers::Offset<
-                           ::flatbuffers::Offset<Frontend::ModuleConnection>>>
+                         ::flatbuffers::Vector<::flatbuffers::Offset<Frontend::ModuleConnection>>>
                              connections) {
         fbb_.AddOffset(RobotConfiguration::VT_CONNECTIONS, connections);
     }
-  explicit RobotConfigurationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit RobotConfigurationBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<RobotConfiguration> Finish() {
@@ -154,11 +147,8 @@ struct RobotConfigurationBuilder {
 
 inline ::flatbuffers::Offset<RobotConfiguration> CreateRobotConfiguration(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>> modules = 0,
-        ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>>
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Frontend::ModuleConnection>>>
-        modules = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<
-        ::flatbuffers::Offset<Frontend::ModuleConnection>>>
         connections = 0) {
     RobotConfigurationBuilder builder_(_fbb);
     builder_.add_connections(connections);
@@ -169,26 +159,20 @@ inline ::flatbuffers::Offset<RobotConfiguration> CreateRobotConfiguration(
 inline ::flatbuffers::Offset<RobotConfiguration> CreateRobotConfigurationDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<::flatbuffers::Offset<RobotModule>> *modules = nullptr,
-    const std::vector<::flatbuffers::Offset<Frontend::ModuleConnection>>
+    const std::vector<::flatbuffers::Offset<Frontend::ModuleConnection>> *connections = nullptr) {
-        *connections = nullptr) {
+    auto modules__ = modules ? _fbb.CreateVector<::flatbuffers::Offset<RobotModule>>(*modules) : 0;
-  auto modules__ =
-      modules ? _fbb.CreateVector<::flatbuffers::Offset<RobotModule>>(*modules)
-              : 0;
     auto connections__ =
         connections
-          ? _fbb.CreateVector<
+            ? _fbb.CreateVector<::flatbuffers::Offset<Frontend::ModuleConnection>>(*connections)
-                ::flatbuffers::Offset<Frontend::ModuleConnection>>(*connections)
             : 0;
     return Frontend::CreateRobotConfiguration(_fbb, modules__, connections__);
 }
 
-inline const Frontend::RobotConfiguration *
+inline const Frontend::RobotConfiguration *GetRobotConfiguration(const void *buf) {
-GetRobotConfiguration(const void *buf) {
     return ::flatbuffers::GetRoot<Frontend::RobotConfiguration>(buf);
 }
 
-inline const Frontend::RobotConfiguration *
+inline const Frontend::RobotConfiguration *GetSizePrefixedRobotConfiguration(const void *buf) {
-GetSizePrefixedRobotConfiguration(const void *buf) {
     return ::flatbuffers::GetSizePrefixedRoot<Frontend::RobotConfiguration>(buf);
 }
 
@@ -196,14 +180,12 @@ inline bool VerifyRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifyBuffer<Frontend::RobotConfiguration>(nullptr);
 }
 
-inline bool
+inline bool VerifySizePrefixedRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
-VerifySizePrefixedRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
+    return verifier.VerifySizePrefixedBuffer<Frontend::RobotConfiguration>(nullptr);
-  return verifier.VerifySizePrefixedBuffer<Frontend::RobotConfiguration>(
-      nullptr);
 }
 
-inline void FinishRobotConfigurationBuffer(
+inline void
-    ::flatbuffers::FlatBufferBuilder &fbb,
+FinishRobotConfigurationBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                ::flatbuffers::Offset<Frontend::RobotConfiguration> root) {
     fbb.Finish(root);
 }

include/flatbuffers_generated/RobotModule_generated.h

@@ -53,10 +53,9 @@ inline const ModuleType (&EnumValuesModuleType())[17] {
 
 inline const char *const *EnumNamesModuleType() {
     static const char *const names[18] = {
-      "SPLITTER",   "SERVO_1",    "DC_MOTOR",   "BATTERY",    "SERVO_2",
+        "SPLITTER",   "SERVO_1",    "DC_MOTOR",   "BATTERY",         "SERVO_2",    "DISPLAY",
-      "DISPLAY",    "GRIPPER",    "SPEAKER",    "IMU",        "DISTANCE_SENSOR",
+        "GRIPPER",    "SPEAKER",    "IMU",        "DISTANCE_SENSOR", "SPLITTER_2", "SPLITTER_3",
-      "SPLITTER_2", "SPLITTER_3", "SPLITTER_4", "SPLITTER_5", "SPLITTER_6",
+        "SPLITTER_4", "SPLITTER_5", "SPLITTER_6", "SPLITTER_7",      "SPLITTER_8", nullptr};
-      "SPLITTER_7", "SPLITTER_8", nullptr};
     return names;
 }
 
@@ -77,14 +76,13 @@ enum Orientation : int8_t {
 };
 
 inline const Orientation (&EnumValuesOrientation())[4] {
-  static const Orientation values[] = {Orientation_Deg0, Orientation_Deg90,
+    static const Orientation values[] = {Orientation_Deg0, Orientation_Deg90, Orientation_Deg180,
-                                       Orientation_Deg180, Orientation_Deg270};
+                                         Orientation_Deg270};
     return values;
 }
 
 inline const char *const *EnumNamesOrientation() {
-  static const char *const names[5] = {"Deg0", "Deg90", "Deg180", "Deg270",
+    static const char *const names[5] = {"Deg0", "Deg90", "Deg180", "Deg270", nullptr};
-                                       nullptr};
     return names;
 }
 
@@ -103,8 +101,7 @@ enum ModuleState : uint8_t {
 };
 
 inline const ModuleState (&EnumValuesModuleState())[2] {
-  static const ModuleState values[] = {ModuleState_NONE,
+    static const ModuleState values[] = {ModuleState_NONE, ModuleState_MotorState};
-                                       ModuleState_MotorState};
     return values;
 }
 
@@ -128,22 +125,20 @@ template <> struct ModuleStateTraits<MotorState> {
     static const ModuleState enum_value = ModuleState_MotorState;
 };
 
-bool VerifyModuleState(::flatbuffers::Verifier &verifier, const void *obj,
+bool VerifyModuleState(::flatbuffers::Verifier &verifier, const void *obj, ModuleState type);
-                       ModuleState type);
+bool VerifyModuleStateVector(::flatbuffers::Verifier &verifier,
-bool VerifyModuleStateVector(
-    ::flatbuffers::Verifier &verifier,
                              const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values,
                              const ::flatbuffers::Vector<uint8_t> *types);
 
 struct MotorState FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     typedef MotorStateBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ANGLE = 4 };
-    VT_ANGLE = 4
+    int32_t angle() const {
-  };
+        return GetField<int32_t>(VT_ANGLE, 0);
-  int32_t angle() const { return GetField<int32_t>(VT_ANGLE, 0); }
+    }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_ANGLE, 4) &&
-           VerifyField<int32_t>(verifier, VT_ANGLE, 4) && verifier.EndTable();
+               verifier.EndTable();
     }
 };
 
@@ -154,8 +149,7 @@ struct MotorStateBuilder {
     void add_angle(int32_t angle) {
         fbb_.AddElement<int32_t>(MotorState::VT_ANGLE, angle, 0);
     }
-  explicit MotorStateBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit MotorStateBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<MotorState> Finish() {
@@ -165,8 +159,8 @@ struct MotorStateBuilder {
     }
 };
 
-inline ::flatbuffers::Offset<MotorState>
+inline ::flatbuffers::Offset<MotorState> CreateMotorState(::flatbuffers::FlatBufferBuilder &_fbb,
-CreateMotorState(::flatbuffers::FlatBufferBuilder &_fbb, int32_t angle = 0) {
+                                                          int32_t angle = 0) {
     MotorStateBuilder builder_(_fbb);
     builder_.add_angle(angle);
     return builder_.Finish();
@@ -180,13 +174,14 @@ struct RobotModule FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
         VT_CONFIGURATION_TYPE = 8,
         VT_CONFIGURATION = 10
     };
-  uint8_t id() const { return GetField<uint8_t>(VT_ID, 0); }
+    uint8_t id() const {
+        return GetField<uint8_t>(VT_ID, 0);
+    }
     ModuleType module_type() const {
         return static_cast<ModuleType>(GetField<int8_t>(VT_MODULE_TYPE, 0));
     }
     ModuleState configuration_type() const {
-    return static_cast<ModuleState>(
+        return static_cast<ModuleState>(GetField<uint8_t>(VT_CONFIGURATION_TYPE, 0));
-        GetField<uint8_t>(VT_CONFIGURATION_TYPE, 0));
     }
     const void *configuration() const {
         return GetPointer<const void *>(VT_CONFIGURATION);
@@ -198,8 +193,7 @@ struct RobotModule FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
                    : nullptr;
     }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ID, 1) &&
-           VerifyField<uint8_t>(verifier, VT_ID, 1) &&
                VerifyField<int8_t>(verifier, VT_MODULE_TYPE, 1) &&
                VerifyField<uint8_t>(verifier, VT_CONFIGURATION_TYPE, 1) &&
                VerifyOffset(verifier, VT_CONFIGURATION) &&
@@ -208,8 +202,7 @@ struct RobotModule FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     }
 };
 
-template <>
+template <> inline const MotorState *RobotModule::configuration_as<MotorState>() const {
-inline const MotorState *RobotModule::configuration_as<MotorState>() const {
     return configuration_as_MotorState();
 }
 
@@ -221,8 +214,7 @@ struct RobotModuleBuilder {
         fbb_.AddElement<uint8_t>(RobotModule::VT_ID, id, 0);
     }
     void add_module_type(ModuleType module_type) {
-    fbb_.AddElement<int8_t>(RobotModule::VT_MODULE_TYPE,
+        fbb_.AddElement<int8_t>(RobotModule::VT_MODULE_TYPE, static_cast<int8_t>(module_type), 0);
-                            static_cast<int8_t>(module_type), 0);
     }
     void add_configuration_type(ModuleState configuration_type) {
         fbb_.AddElement<uint8_t>(RobotModule::VT_CONFIGURATION_TYPE,
@@ -231,8 +223,7 @@ struct RobotModuleBuilder {
     void add_configuration(::flatbuffers::Offset<void> configuration) {
         fbb_.AddOffset(RobotModule::VT_CONFIGURATION, configuration);
     }
-  explicit RobotModuleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit RobotModuleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<RobotModule> Finish() {
@@ -255,8 +246,8 @@ CreateRobotModule(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t id = 0,
     return builder_.Finish();
 }
 
-inline bool VerifyModuleState(::flatbuffers::Verifier &verifier,
+inline bool VerifyModuleState(::flatbuffers::Verifier &verifier, const void *obj,
-                              const void *obj, ModuleState type) {
+                              ModuleState type) {
     switch (type) {
     case ModuleState_NONE: {
         return true;
@@ -270,8 +261,8 @@ inline bool VerifyModuleState(::flatbuffers::Verifier &verifier,
     }
 }
 
-inline bool VerifyModuleStateVector(
+inline bool
-    ::flatbuffers::Verifier &verifier,
+VerifyModuleStateVector(::flatbuffers::Verifier &verifier,
                         const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values,
                         const ::flatbuffers::Vector<uint8_t> *types) {
     if (!values || !types)
@@ -279,8 +270,7 @@ inline bool VerifyModuleStateVector(
     if (values->size() != types->size())
         return false;
     for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
-    if (!VerifyModuleState(verifier, values->Get(i),
+        if (!VerifyModuleState(verifier, values->Get(i), types->GetEnum<ModuleState>(i))) {
-                           types->GetEnum<ModuleState>(i))) {
             return false;
         }
     }
@@ -299,8 +289,7 @@ inline bool VerifyRobotModuleBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifyBuffer<RobotModule>(nullptr);
 }
 
-inline bool
+inline bool VerifySizePrefixedRobotModuleBuffer(::flatbuffers::Verifier &verifier) {
-VerifySizePrefixedRobotModuleBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifySizePrefixedBuffer<RobotModule>(nullptr);
 }
 
@@ -309,8 +298,7 @@ inline void FinishRobotModuleBuffer(::flatbuffers::FlatBufferBuilder &fbb,
     fbb.Finish(root);
 }
 
-inline void
+inline void FinishSizePrefixedRobotModuleBuffer(::flatbuffers::FlatBufferBuilder &fbb,
-FinishSizePrefixedRobotModuleBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                                 ::flatbuffers::Offset<RobotModule> root) {
     fbb.FinishSizePrefixed(root);
 }

include/flatbuffers_generated/SensorMessage_generated.h

@@ -36,15 +36,14 @@ enum SensorValue : uint8_t {
 };
 
 inline const SensorValue (&EnumValuesSensorValue())[4] {
-  static const SensorValue values[] = {
+    static const SensorValue values[] = {SensorValue_NONE, SensorValue_TargetAngle,
-      SensorValue_NONE, SensorValue_TargetAngle, SensorValue_CurrentAngle,
+                                         SensorValue_CurrentAngle, SensorValue_CurrentText};
-      SensorValue_CurrentText};
     return values;
 }
 
 inline const char *const *EnumNamesSensorValue() {
-  static const char *const names[5] = {"NONE", "TargetAngle", "CurrentAngle",
+    static const char *const names[5] = {"NONE", "TargetAngle", "CurrentAngle", "CurrentText",
-                                       "CurrentText", nullptr};
+                                         nullptr};
     return names;
 }
 
@@ -71,22 +70,20 @@ template <> struct SensorValueTraits<Messaging::CurrentText> {
     static const SensorValue enum_value = SensorValue_CurrentText;
 };
 
-bool VerifySensorValue(::flatbuffers::Verifier &verifier, const void *obj,
+bool VerifySensorValue(::flatbuffers::Verifier &verifier, const void *obj, SensorValue type);
-                       SensorValue type);
+bool VerifySensorValueVector(::flatbuffers::Verifier &verifier,
-bool VerifySensorValueVector(
-    ::flatbuffers::Verifier &verifier,
                              const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values,
                              const ::flatbuffers::Vector<uint8_t> *types);
 
 struct TargetAngle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     typedef TargetAngleBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 };
-    VT_VALUE = 4
+    int16_t value() const {
-  };
+        return GetField<int16_t>(VT_VALUE, 0);
-  int16_t value() const { return GetField<int16_t>(VT_VALUE, 0); }
+    }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<int16_t>(verifier, VT_VALUE, 2) &&
-           VerifyField<int16_t>(verifier, VT_VALUE, 2) && verifier.EndTable();
+               verifier.EndTable();
     }
 };
 
@@ -97,8 +94,7 @@ struct TargetAngleBuilder {
     void add_value(int16_t value) {
         fbb_.AddElement<int16_t>(TargetAngle::VT_VALUE, value, 0);
     }
-  explicit TargetAngleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit TargetAngleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<TargetAngle> Finish() {
@@ -108,8 +104,8 @@ struct TargetAngleBuilder {
     }
 };
 
-inline ::flatbuffers::Offset<TargetAngle>
+inline ::flatbuffers::Offset<TargetAngle> CreateTargetAngle(::flatbuffers::FlatBufferBuilder &_fbb,
-CreateTargetAngle(::flatbuffers::FlatBufferBuilder &_fbb, int16_t value = 0) {
+                                                            int16_t value = 0) {
     TargetAngleBuilder builder_(_fbb);
     builder_.add_value(value);
     return builder_.Finish();
@@ -117,9 +113,7 @@ CreateTargetAngle(::flatbuffers::FlatBufferBuilder &_fbb, int16_t value = 0) {
 
 struct CurrentText FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     typedef CurrentTextBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 };
-    VT_VALUE = 4
-  };
     const ::flatbuffers::String *value() const {
         return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
     }
@@ -136,8 +130,7 @@ struct CurrentTextBuilder {
     void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
         fbb_.AddOffset(CurrentText::VT_VALUE, value);
     }
-  explicit CurrentTextBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit CurrentTextBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<CurrentText> Finish() {
@@ -156,21 +149,20 @@ CreateCurrentText(::flatbuffers::FlatBufferBuilder &_fbb,
 }
 
 inline ::flatbuffers::Offset<CurrentText>
-CreateCurrentTextDirect(::flatbuffers::FlatBufferBuilder &_fbb,
+CreateCurrentTextDirect(::flatbuffers::FlatBufferBuilder &_fbb, const char *value = nullptr) {
-                        const char *value = nullptr) {
     auto value__ = value ? _fbb.CreateString(value) : 0;
     return Messaging::CreateCurrentText(_fbb, value__);
 }
 
 struct CurrentAngle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     typedef CurrentAngleBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 };
-    VT_VALUE = 4
+    int16_t value() const {
-  };
+        return GetField<int16_t>(VT_VALUE, 0);
-  int16_t value() const { return GetField<int16_t>(VT_VALUE, 0); }
+    }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<int16_t>(verifier, VT_VALUE, 2) &&
-           VerifyField<int16_t>(verifier, VT_VALUE, 2) && verifier.EndTable();
+               verifier.EndTable();
     }
 };
 
@@ -181,8 +173,7 @@ struct CurrentAngleBuilder {
     void add_value(int16_t value) {
         fbb_.AddElement<int16_t>(CurrentAngle::VT_VALUE, value, 0);
     }
-  explicit CurrentAngleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit CurrentAngleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<CurrentAngle> Finish() {
@@ -209,17 +200,13 @@ struct SensorMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
         return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_VALUES_TYPE);
     }
     const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values() const {
-    return GetPointer<
+        return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_VALUES);
-        const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_VALUES);
     }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES_TYPE) &&
-           VerifyOffset(verifier, VT_VALUES_TYPE) &&
+               verifier.VerifyVector(values_type()) && VerifyOffset(verifier, VT_VALUES) &&
-           verifier.VerifyVector(values_type()) &&
-           VerifyOffset(verifier, VT_VALUES) &&
                verifier.VerifyVector(values()) &&
-           VerifySensorValueVector(verifier, values(), values_type()) &&
+               VerifySensorValueVector(verifier, values(), values_type()) && verifier.EndTable();
-           verifier.EndTable();
     }
 };
 
@@ -227,17 +214,14 @@ struct SensorMessageBuilder {
     typedef SensorMessage Table;
     ::flatbuffers::FlatBufferBuilder &fbb_;
     ::flatbuffers::uoffset_t start_;
-  void add_values_type(
+    void add_values_type(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values_type) {
-      ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values_type) {
         fbb_.AddOffset(SensorMessage::VT_VALUES_TYPE, values_type);
     }
-  void add_values(
+    void
-      ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>>
+    add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> values) {
-          values) {
         fbb_.AddOffset(SensorMessage::VT_VALUES, values);
     }
-  explicit SensorMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit SensorMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<SensorMessage> Finish() {
@@ -250,27 +234,24 @@ struct SensorMessageBuilder {
 inline ::flatbuffers::Offset<SensorMessage> CreateSensorMessage(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values_type = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>>
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> values = 0) {
-        values = 0) {
     SensorMessageBuilder builder_(_fbb);
     builder_.add_values(values);
     builder_.add_values_type(values_type);
     return builder_.Finish();
 }
 
-inline ::flatbuffers::Offset<SensorMessage> CreateSensorMessageDirect(
+inline ::flatbuffers::Offset<SensorMessage>
-    ::flatbuffers::FlatBufferBuilder &_fbb,
+CreateSensorMessageDirect(::flatbuffers::FlatBufferBuilder &_fbb,
                           const std::vector<uint8_t> *values_type = nullptr,
                           const std::vector<::flatbuffers::Offset<void>> *values = nullptr) {
-  auto values_type__ =
+    auto values_type__ = values_type ? _fbb.CreateVector<uint8_t>(*values_type) : 0;
-      values_type ? _fbb.CreateVector<uint8_t>(*values_type) : 0;
+    auto values__ = values ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*values) : 0;
-  auto values__ =
-      values ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*values) : 0;
     return Messaging::CreateSensorMessage(_fbb, values_type__, values__);
 }
 
-inline bool VerifySensorValue(::flatbuffers::Verifier &verifier,
+inline bool VerifySensorValue(::flatbuffers::Verifier &verifier, const void *obj,
-                              const void *obj, SensorValue type) {
+                              SensorValue type) {
     switch (type) {
     case SensorValue_NONE: {
         return true;
@@ -292,8 +273,8 @@ inline bool VerifySensorValue(::flatbuffers::Verifier &verifier,
     }
 }
 
-inline bool VerifySensorValueVector(
+inline bool
-    ::flatbuffers::Verifier &verifier,
+VerifySensorValueVector(::flatbuffers::Verifier &verifier,
                         const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values,
                         const ::flatbuffers::Vector<uint8_t> *types) {
     if (!values || !types)
@@ -301,8 +282,7 @@ inline bool VerifySensorValueVector(
     if (values->size() != types->size())
         return false;
     for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
-    if (!VerifySensorValue(verifier, values->Get(i),
+        if (!VerifySensorValue(verifier, values->Get(i), types->GetEnum<SensorValue>(i))) {
-                           types->GetEnum<SensorValue>(i))) {
             return false;
         }
     }
@@ -313,8 +293,7 @@ inline const Messaging::SensorMessage *GetSensorMessage(const void *buf) {
     return ::flatbuffers::GetRoot<Messaging::SensorMessage>(buf);
 }
 
-inline const Messaging::SensorMessage *
+inline const Messaging::SensorMessage *GetSizePrefixedSensorMessage(const void *buf) {
-GetSizePrefixedSensorMessage(const void *buf) {
     return ::flatbuffers::GetSizePrefixedRoot<Messaging::SensorMessage>(buf);
 }
 
@@ -322,19 +301,17 @@ inline bool VerifySensorMessageBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifyBuffer<Messaging::SensorMessage>(nullptr);
 }
 
-inline bool
+inline bool VerifySizePrefixedSensorMessageBuffer(::flatbuffers::Verifier &verifier) {
-VerifySizePrefixedSensorMessageBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifySizePrefixedBuffer<Messaging::SensorMessage>(nullptr);
 }
 
-inline void FinishSensorMessageBuffer(
+inline void FinishSensorMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::FlatBufferBuilder &fbb,
                                       ::flatbuffers::Offset<Messaging::SensorMessage> root) {
     fbb.Finish(root);
 }
 
-inline void FinishSizePrefixedSensorMessageBuffer(
+inline void
-    ::flatbuffers::FlatBufferBuilder &fbb,
+FinishSizePrefixedSensorMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                       ::flatbuffers::Offset<Messaging::SensorMessage> root) {
     fbb.FinishSizePrefixed(root);
 }

include/flatbuffers_generated/TextControlMessage_generated.h

@@ -17,12 +17,9 @@ namespace Messaging {
 struct TextControlMessage;
 struct TextControlMessageBuilder;
 
-struct TextControlMessage FLATBUFFERS_FINAL_CLASS
+struct TextControlMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-    : private ::flatbuffers::Table {
     typedef TextControlMessageBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_MESSAGE = 4 };
-    VT_MESSAGE = 4
-  };
     const ::flatbuffers::String *message() const {
         return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
     }
@@ -39,8 +36,7 @@ struct TextControlMessageBuilder {
     void add_message(::flatbuffers::Offset<::flatbuffers::String> message) {
         fbb_.AddOffset(TextControlMessage::VT_MESSAGE, message);
     }
-  explicit TextControlMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit TextControlMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<TextControlMessage> Finish() {
@@ -50,8 +46,8 @@ struct TextControlMessageBuilder {
     }
 };
 
-inline ::flatbuffers::Offset<TextControlMessage> CreateTextControlMessage(
+inline ::flatbuffers::Offset<TextControlMessage>
-    ::flatbuffers::FlatBufferBuilder &_fbb,
+CreateTextControlMessage(::flatbuffers::FlatBufferBuilder &_fbb,
                          ::flatbuffers::Offset<::flatbuffers::String> message = 0) {
     TextControlMessageBuilder builder_(_fbb);
     builder_.add_message(message);
@@ -65,13 +61,11 @@ CreateTextControlMessageDirect(::flatbuffers::FlatBufferBuilder &_fbb,
     return Messaging::CreateTextControlMessage(_fbb, message__);
 }
 
-inline const Messaging::TextControlMessage *
+inline const Messaging::TextControlMessage *GetTextControlMessage(const void *buf) {
-GetTextControlMessage(const void *buf) {
     return ::flatbuffers::GetRoot<Messaging::TextControlMessage>(buf);
 }
 
-inline const Messaging::TextControlMessage *
+inline const Messaging::TextControlMessage *GetSizePrefixedTextControlMessage(const void *buf) {
-GetSizePrefixedTextControlMessage(const void *buf) {
     return ::flatbuffers::GetSizePrefixedRoot<Messaging::TextControlMessage>(buf);
 }
 
@@ -79,14 +73,12 @@ inline bool VerifyTextControlMessageBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifyBuffer<Messaging::TextControlMessage>(nullptr);
 }
 
-inline bool
+inline bool VerifySizePrefixedTextControlMessageBuffer(::flatbuffers::Verifier &verifier) {
-VerifySizePrefixedTextControlMessageBuffer(::flatbuffers::Verifier &verifier) {
+    return verifier.VerifySizePrefixedBuffer<Messaging::TextControlMessage>(nullptr);
-  return verifier.VerifySizePrefixedBuffer<Messaging::TextControlMessage>(
-      nullptr);
 }
 
-inline void FinishTextControlMessageBuffer(
+inline void
-    ::flatbuffers::FlatBufferBuilder &fbb,
+FinishTextControlMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                ::flatbuffers::Offset<Messaging::TextControlMessage> root) {
     fbb.Finish(root);
 }

include/flatbuffers_generated/TopologyMessage_generated.h

@@ -27,8 +27,7 @@ enum ConnectionType : int8_t {
 };
 
 inline const ConnectionType (&EnumValuesConnectionType())[2] {
-  static const ConnectionType values[] = {ConnectionType_DIRECT,
+    static const ConnectionType values[] = {ConnectionType_DIRECT, ConnectionType_HOP};
-                                          ConnectionType_HOP};
     return values;
 }
 
@@ -56,30 +55,32 @@ struct TopologyMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
         VT_LEADER = 16,
         VT_FIRMWARE = 18
     };
-  uint8_t module_id() const { return GetField<uint8_t>(VT_MODULE_ID, 0); }
+    uint8_t module_id() const {
+        return GetField<uint8_t>(VT_MODULE_ID, 0);
+    }
     ModuleType module_type() const {
         return static_cast<ModuleType>(GetField<int8_t>(VT_MODULE_TYPE, 0));
     }
-  uint8_t num_channels() const { return GetField<uint8_t>(VT_NUM_CHANNELS, 0); }
+    uint8_t num_channels() const {
+        return GetField<uint8_t>(VT_NUM_CHANNELS, 0);
+    }
     const ::flatbuffers::Vector<uint8_t> *channel_to_module() const {
-    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(
+        return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CHANNEL_TO_MODULE);
-        VT_CHANNEL_TO_MODULE);
     }
     const ::flatbuffers::Vector<int8_t> *channel_to_orientation() const {
-    return GetPointer<const ::flatbuffers::Vector<int8_t> *>(
+        return GetPointer<const ::flatbuffers::Vector<int8_t> *>(VT_CHANNEL_TO_ORIENTATION);
-        VT_CHANNEL_TO_ORIENTATION);
     }
     Messaging::ConnectionType connection() const {
-    return static_cast<Messaging::ConnectionType>(
+        return static_cast<Messaging::ConnectionType>(GetField<int8_t>(VT_CONNECTION, 0));
-        GetField<int8_t>(VT_CONNECTION, 0));
+    }
+    uint8_t leader() const {
+        return GetField<uint8_t>(VT_LEADER, 0);
     }
-  uint8_t leader() const { return GetField<uint8_t>(VT_LEADER, 0); }
     const ::flatbuffers::String *firmware() const {
         return GetPointer<const ::flatbuffers::String *>(VT_FIRMWARE);
     }
     bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
+        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_MODULE_ID, 1) &&
-           VerifyField<uint8_t>(verifier, VT_MODULE_ID, 1) &&
                VerifyField<int8_t>(verifier, VT_MODULE_TYPE, 1) &&
                VerifyField<uint8_t>(verifier, VT_NUM_CHANNELS, 1) &&
                VerifyOffset(verifier, VT_CHANNEL_TO_MODULE) &&
@@ -88,8 +89,8 @@ struct TopologyMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
                verifier.VerifyVector(channel_to_orientation()) &&
                VerifyField<int8_t>(verifier, VT_CONNECTION, 1) &&
                VerifyField<uint8_t>(verifier, VT_LEADER, 1) &&
-           VerifyOffset(verifier, VT_FIRMWARE) &&
+               VerifyOffset(verifier, VT_FIRMWARE) && verifier.VerifyString(firmware()) &&
-           verifier.VerifyString(firmware()) && verifier.EndTable();
+               verifier.EndTable();
     }
 };
 
@@ -101,25 +102,22 @@ struct TopologyMessageBuilder {
         fbb_.AddElement<uint8_t>(TopologyMessage::VT_MODULE_ID, module_id, 0);
     }
     void add_module_type(ModuleType module_type) {
-    fbb_.AddElement<int8_t>(TopologyMessage::VT_MODULE_TYPE,
+        fbb_.AddElement<int8_t>(TopologyMessage::VT_MODULE_TYPE, static_cast<int8_t>(module_type),
-                            static_cast<int8_t>(module_type), 0);
+                                0);
     }
     void add_num_channels(uint8_t num_channels) {
         fbb_.AddElement<uint8_t>(TopologyMessage::VT_NUM_CHANNELS, num_channels, 0);
     }
-  void add_channel_to_module(
+    void
-      ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> channel_to_module) {
+    add_channel_to_module(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> channel_to_module) {
         fbb_.AddOffset(TopologyMessage::VT_CHANNEL_TO_MODULE, channel_to_module);
     }
     void add_channel_to_orientation(
-      ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>>
+        ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> channel_to_orientation) {
-          channel_to_orientation) {
+        fbb_.AddOffset(TopologyMessage::VT_CHANNEL_TO_ORIENTATION, channel_to_orientation);
-    fbb_.AddOffset(TopologyMessage::VT_CHANNEL_TO_ORIENTATION,
-                   channel_to_orientation);
     }
     void add_connection(Messaging::ConnectionType connection) {
-    fbb_.AddElement<int8_t>(TopologyMessage::VT_CONNECTION,
+        fbb_.AddElement<int8_t>(TopologyMessage::VT_CONNECTION, static_cast<int8_t>(connection), 0);
-                            static_cast<int8_t>(connection), 0);
     }
     void add_leader(uint8_t leader) {
         fbb_.AddElement<uint8_t>(TopologyMessage::VT_LEADER, leader, 0);
@@ -127,8 +125,7 @@ struct TopologyMessageBuilder {
     void add_firmware(::flatbuffers::Offset<::flatbuffers::String> firmware) {
         fbb_.AddOffset(TopologyMessage::VT_FIRMWARE, firmware);
     }
-  explicit TopologyMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+    explicit TopologyMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
-      : fbb_(_fbb) {
         start_ = fbb_.StartTable();
     }
     ::flatbuffers::Offset<TopologyMessage> Finish() {
@@ -142,10 +139,8 @@ inline ::flatbuffers::Offset<TopologyMessage> CreateTopologyMessage(
     ::flatbuffers::FlatBufferBuilder &_fbb, uint8_t module_id = 0,
     ModuleType module_type = ModuleType_SPLITTER, uint8_t num_channels = 0,
     ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> channel_to_module = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>>
+    ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> channel_to_orientation = 0,
-        channel_to_orientation = 0,
+    Messaging::ConnectionType connection = Messaging::ConnectionType_DIRECT, uint8_t leader = 0,
-    Messaging::ConnectionType connection = Messaging::ConnectionType_DIRECT,
-    uint8_t leader = 0,
     ::flatbuffers::Offset<::flatbuffers::String> firmware = 0) {
     TopologyMessageBuilder builder_(_fbb);
     builder_.add_firmware(firmware);
@@ -159,8 +154,8 @@ inline ::flatbuffers::Offset<TopologyMessage> CreateTopologyMessage(
     return builder_.Finish();
 }
 
-inline ::flatbuffers::Offset<TopologyMessage> CreateTopologyMessageDirect(
+inline ::flatbuffers::Offset<TopologyMessage>
-    ::flatbuffers::FlatBufferBuilder &_fbb, uint8_t module_id = 0,
+CreateTopologyMessageDirect(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t module_id = 0,
                             ModuleType module_type = ModuleType_SPLITTER, uint8_t num_channels = 0,
                             const std::vector<uint8_t> *channel_to_module = nullptr,
                             const std::vector<int8_t> *channel_to_orientation = nullptr,
@@ -169,21 +164,18 @@ inline ::flatbuffers::Offset<TopologyMessage> CreateTopologyMessageDirect(
     auto channel_to_module__ =
         channel_to_module ? _fbb.CreateVector<uint8_t>(*channel_to_module) : 0;
     auto channel_to_orientation__ =
-      channel_to_orientation
+        channel_to_orientation ? _fbb.CreateVector<int8_t>(*channel_to_orientation) : 0;
-          ? _fbb.CreateVector<int8_t>(*channel_to_orientation)
-          : 0;
     auto firmware__ = firmware ? _fbb.CreateString(firmware) : 0;
-  return Messaging::CreateTopologyMessage(
+    return Messaging::CreateTopologyMessage(_fbb, module_id, module_type, num_channels,
-      _fbb, module_id, module_type, num_channels, channel_to_module__,
+                                            channel_to_module__, channel_to_orientation__,
-      channel_to_orientation__, connection, leader, firmware__);
+                                            connection, leader, firmware__);
 }
 
 inline const Messaging::TopologyMessage *GetTopologyMessage(const void *buf) {
     return ::flatbuffers::GetRoot<Messaging::TopologyMessage>(buf);
 }
 
-inline const Messaging::TopologyMessage *
+inline const Messaging::TopologyMessage *GetSizePrefixedTopologyMessage(const void *buf) {
-GetSizePrefixedTopologyMessage(const void *buf) {
     return ::flatbuffers::GetSizePrefixedRoot<Messaging::TopologyMessage>(buf);
 }
 
@@ -191,19 +183,17 @@ inline bool VerifyTopologyMessageBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifyBuffer<Messaging::TopologyMessage>(nullptr);
 }
 
-inline bool
+inline bool VerifySizePrefixedTopologyMessageBuffer(::flatbuffers::Verifier &verifier) {
-VerifySizePrefixedTopologyMessageBuffer(::flatbuffers::Verifier &verifier) {
     return verifier.VerifySizePrefixedBuffer<Messaging::TopologyMessage>(nullptr);
 }
 
-inline void FinishTopologyMessageBuffer(
+inline void FinishTopologyMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::FlatBufferBuilder &fbb,
                                         ::flatbuffers::Offset<Messaging::TopologyMessage> root) {
     fbb.Finish(root);
 }
 
-inline void FinishSizePrefixedTopologyMessageBuffer(
+inline void
-    ::flatbuffers::FlatBufferBuilder &fbb,
+FinishSizePrefixedTopologyMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
                                         ::flatbuffers::Offset<Messaging::TopologyMessage> root) {
     fbb.FinishSizePrefixed(root);
 }

include/lib_c_control.h

@@ -1,6 +1,8 @@
 #ifndef CONTROL_LIBRARY_H
 #define CONTROL_LIBRARY_H
 
+#include <stdint.h>
+
 #if defined(_WIN32) || defined(__CYGWIN__)
 #ifdef CONTROL_EXPORTS
 #define LIB_API __declspec(dllexport)
@@ -17,10 +19,12 @@ LIB_API void cleanup();
 LIB_API int send_angle_control(int module_id, int angle);
 LIB_API char *get_configuration(int *size_out);
 
-LIB_API bool control_sentry_init(const char *dsn, const char *environment,
+LIB_API bool remote_call_c(uint8_t function_tag, uint8_t module, const uint8_t *params,
-                                 const char *release);
+                           uint16_t params_len, uint8_t *out_buffer, uint16_t out_buffer_capacity,
-LIB_API void control_sentry_set_app_info(const char *app_name,
+                           uint16_t *out_bytes_written);
-                                         const char *app_version,
+
+LIB_API bool control_sentry_init(const char *dsn, const char *environment, const char *release);
+LIB_API void control_sentry_set_app_info(const char *app_name, const char *app_version,
                                          const char *build_number);
 LIB_API void control_sentry_shutdown(void);
 }

include/libcontrol.h

@@ -27,7 +27,7 @@
  */
 class RobotController {
 
-public:
+  public:
     /**
    * \brief Creates a new RobotController.
    *
@@ -38,8 +38,7 @@ public:
         : m_messaging_interface(std::make_unique<MessagingInterface>()),
           m_metadata_loop(std::thread(&RobotController::metadata_loop, this)),
           m_transmit_loop(std::thread(&RobotController::transmit_loop, this)),
-        m_configuration_loop(
+          m_configuration_loop(std::thread(&RobotController::configuration_loop, this)),
-            std::thread(&RobotController::configuration_loop, this)),
           m_sensor_loop(std::thread(&RobotController::sensor_loop, this)),
           m_expiry_looop(std::thread(&RobotController::expiry_loop, this)) {
         m_logger = spdlog::basic_logger_mt("default_logger", "libcontrol.log");
@@ -101,11 +100,13 @@ public:
    */
     void fetchDirectlyConnectedModules(bool block);
 
-private:
+    std::optional<std::unique_ptr<std::vector<uint8_t>>>
+    remote_call(uint8_t function_tag, uint8_t module, const std::vector<uint8_t> &parameters);
+
+  private:
     std::shared_ptr<spdlog::logger> m_logger;
     std::unordered_map<uint8_t, std::shared_ptr<Module>> m_id_to_module{};
-  std::unordered_map<uint8_t,
+    std::unordered_map<uint8_t, std::vector<Flatbuffers::ModuleConnectionInstance>>
-                     std::vector<Flatbuffers::ModuleConnectionInstance>>
         m_connection_map{};
     std::shared_mutex m_module_lock{};
     std::shared_mutex m_connection_lock{};

include/util/Event.h

@@ -7,17 +7,18 @@
 class Event;
 
 class CallbackHandle {
-public:
+  public:
-  CallbackHandle(Event *evt, int id) : evt(evt), id(id) {}
+    CallbackHandle(Event *evt, int id) : evt(evt), id(id) {
+    }
     ~CallbackHandle();
 
-private:
+  private:
     Event *evt;
     int id;
 };
 
 class Event {
-public:
+  public:
     using Callback = std::function<void()>;
 
     CallbackHandle addListener(Callback cb) {
@@ -26,14 +27,16 @@ public:
         return CallbackHandle(this, id);
     }
 
-  void remove(int id) { callbacks.erase(id); }
+    void remove(int id) {
+        callbacks.erase(id);
+    }
 
     void fire() {
         for (auto &kv : callbacks)
             kv.second();
     }
 
-private:
+  private:
     friend class CallbackHandle;
     std::unordered_map<int, Callback> callbacks;
     int nextId = 0;

src/Module.cpp

@@ -4,20 +4,27 @@
 
 #include "Module.h"
 
-std::vector<neighbour> Module::get_neighbours() { return m_neighbours; }
+std::vector<neighbour> Module::get_neighbours() {
+    return m_neighbours;
+}
 
-uint8_t Module::get_device_id() { return m_device_id; }
+uint8_t Module::get_device_id() {
+    return m_device_id;
+}
 
-ModuleType Module::get_type() { return m_module_type; }
+ModuleType Module::get_type() {
+    return m_module_type;
+}
 
 Messaging::ConnectionType Module::get_connection_type() {
     return m_connection_type;
 }
 
-uint8_t Module::get_leader() { return m_leader; }
+uint8_t Module::get_leader() {
+    return m_leader;
+}
 
-std::chrono::time_point<std::chrono::system_clock>
+std::chrono::time_point<std::chrono::system_clock> Module::get_last_updated_time() {
-Module::get_last_updated_time() {
     return m_last_updated;
 }
 
@@ -29,8 +36,8 @@ void Module::update_module_metadata(const Messaging::TopologyMessage &message) {
     m_last_updated = std::chrono::system_clock::now();
 
     m_neighbours.clear();
-  for (auto [id, ori] : std::views::zip(*message.channel_to_module(),
+    for (auto [id, ori] :
-                                        *message.channel_to_orientation())) {
+         std::views::zip(*message.channel_to_module(), *message.channel_to_orientation())) {
         m_neighbours.emplace_back(neighbour{id, static_cast<Orientation>(ori)});
     }
 }

src/ModuleFactory.cpp

@@ -10,8 +10,8 @@
 #define SERVO1_MIN_ANGLE 0
 #define SERVO1_DEFAULT_ANGLE 90
 
-std::shared_ptr<Module> ModuleFactory::createModule(
+std::shared_ptr<Module>
-    uint8_t device_id, ModuleType type,
+ModuleFactory::createModule(uint8_t device_id, ModuleType type,
                             std::shared_ptr<MessagingInterface> &messaging_interface) {
     switch (type) {
     case ModuleType_SPLITTER:
@@ -22,8 +22,7 @@ std::shared_ptr<Module> ModuleFactory::createModule(
     case ModuleType_SERVO_2:
     case ModuleType_GRIPPER:
         return std::make_shared<BoundedPositionalActuator1D>(
-        device_id, type, SERVO1_MAX_ANGLE, SERVO1_MIN_ANGLE,
+            device_id, type, SERVO1_MAX_ANGLE, SERVO1_MIN_ANGLE, SERVO1_DEFAULT_ANGLE);
-        SERVO1_DEFAULT_ANGLE);
     case ModuleType_DC_MOTOR:
         return std::make_shared<PositionalActuator1D>(device_id, type);
     case ModuleType_DISPLAY:

src/actuators/BoundedPositionalActuator1D.cpp

@@ -10,7 +10,9 @@ double BoundedPositionalActuator1D::get_position() {
     return m_current_position;
 }
 
-std::string BoundedPositionalActuator1D::get_text() { return ""; }
+std::string BoundedPositionalActuator1D::get_text() {
+    return "";
+}
 
 void BoundedPositionalActuator1D::actuate(double position) {
     if (position < m_min_value || position > m_max_value) {
@@ -20,9 +22,11 @@ void BoundedPositionalActuator1D::actuate(double position) {
     m_target_position = position;
 }
 
-void BoundedPositionalActuator1D::actuate(double x, double y) {}
+void BoundedPositionalActuator1D::actuate(double x, double y) {
+}
 
-void BoundedPositionalActuator1D::actuate(const std::string &text) {}
+void BoundedPositionalActuator1D::actuate(const std::string &text) {
+}
 
 std::vector<uint8_t> BoundedPositionalActuator1D::get_actuation_message() {
     std::vector<uint8_t> message{};
@@ -31,21 +35,16 @@ std::vector<uint8_t> BoundedPositionalActuator1D::get_actuation_message() {
         return message;
     }
 
-  auto [data, size] =
+    auto [data, size] = acm_builder->build_angle_control_message(m_target_position);
-      acm_builder->build_angle_control_message(m_target_position);
     message.resize(size);
     memcpy(message.data(), data, size);
     return message;
 }
 
-void BoundedPositionalActuator1D::update_sensor_data(
+void BoundedPositionalActuator1D::update_sensor_data(const Flatbuffers::sensor_value &value) {
-    const Flatbuffers::sensor_value &value) {
+    std::visit(overloaded{
-  std::visit(
-      overloaded{
                    [this](Flatbuffers::target_angle a) { m_current_position = a.angle; },
-          [this](Flatbuffers::current_angle a) {
+                   [this](Flatbuffers::current_angle a) { m_current_position = a.angle; },
-            m_current_position = a.angle;
-          },
                    [this](Flatbuffers::current_text /*t*/) {},
                },
                value);

src/actuators/OledActuator.cpp

@@ -3,15 +3,23 @@
 #include "util/Variant.h"
 #include <cstring>
 
-double OledActuator::get_position() { return 0.0; }
+double OledActuator::get_position() {
+    return 0.0;
+}
 
-std::string OledActuator::get_text() { return m_current_text; }
+std::string OledActuator::get_text() {
+    return m_current_text;
+}
 
-void OledActuator::actuate(double /* position */) {}
+void OledActuator::actuate(double /* position */) {
+}
 
-void OledActuator::actuate(double /* x */, double /* y */) {}
+void OledActuator::actuate(double /* x */, double /* y */) {
+}
 
-void OledActuator::actuate(const std::string &text) { m_target_text = text; }
+void OledActuator::actuate(const std::string &text) {
+    m_target_text = text;
+}
 
 std::vector<uint8_t> OledActuator::get_actuation_message() {
     std::vector<uint8_t> message{};
@@ -20,16 +28,14 @@ std::vector<uint8_t> OledActuator::get_actuation_message() {
         return message;
     }
 
-  auto [data, size] =
+    auto [data, size] = m_text_message_builder->build_text_control_message(m_target_text);
-      m_text_message_builder->build_text_control_message(m_target_text);
     message.resize(size);
     memcpy(message.data(), data, size);
     return message;
 }
 
 void OledActuator::update_sensor_data(const Flatbuffers::sensor_value &value) {
-  std::visit(
+    std::visit(overloaded{
-      overloaded{
                    [this](Flatbuffers::target_angle /* a */) {},
                    [this](Flatbuffers::current_angle /* a */) {},
                    [this](Flatbuffers::current_text t) { m_current_text = t.text; },

src/actuators/PositionalActuator1D.cpp

@@ -3,17 +3,23 @@
 #include "util/Variant.h"
 #include <cstring>
 
-double PositionalActuator1D::get_position() { return m_current_position; }
+double PositionalActuator1D::get_position() {
+    return m_current_position;
+}
 
-std::string PositionalActuator1D::get_text() { return ""; }
+std::string PositionalActuator1D::get_text() {
+    return "";
+}
 
 void PositionalActuator1D::actuate(double position) {
     m_target_position = position;
 }
 
-void PositionalActuator1D::actuate(double /* x */, double /* y */) {}
+void PositionalActuator1D::actuate(double /* x */, double /* y */) {
+}
 
-void PositionalActuator1D::actuate(const std::string &text) {}
+void PositionalActuator1D::actuate(const std::string &text) {
+}
 
 std::vector<uint8_t> PositionalActuator1D::get_actuation_message() {
     std::vector<uint8_t> message{};
@@ -22,22 +28,16 @@ std::vector<uint8_t> PositionalActuator1D::get_actuation_message() {
         return message;
     }
 
-  auto [data, size] =
+    auto [data, size] = m_acm_builder->build_angle_control_message(m_target_position);
-      m_acm_builder->build_angle_control_message(m_target_position);
     message.resize(size);
     memcpy(message.data(), data, size);
     return message;
 }
 
-void PositionalActuator1D::update_sensor_data(
+void PositionalActuator1D::update_sensor_data(const Flatbuffers::sensor_value &value) {
-    const Flatbuffers::sensor_value &value) {
     std::visit(overloaded{
-                 [this](Flatbuffers::target_angle a) {
+                   [this](Flatbuffers::target_angle a) { m_board_target_position = a.angle; },
-                   m_board_target_position = a.angle;
+                   [this](Flatbuffers::current_angle a) { m_current_position = a.angle; },
-                 },
-                 [this](Flatbuffers::current_angle a) {
-                   m_current_position = a.angle;
-                 },
                    [this](Flatbuffers::current_text /*t*/) {},
                },
                value);

src/flatbuffers/AngleControlMessageBuilder.cpp

@@ -10,8 +10,7 @@ AngleControlMessageBuilder::parse_angle_control_message(const uint8_t *buffer) {
     return flatbuffers::GetRoot<Messaging::AngleControlMessage>(buffer);
 }
 
-SerializedMessage
+SerializedMessage AngleControlMessageBuilder::build_angle_control_message(const int16_t angle) {
-AngleControlMessageBuilder::build_angle_control_message(const int16_t angle) {
     builder_.Clear();
 
     const auto message = Messaging::CreateAngleControlMessage(builder_, angle);

src/flatbuffers/RobotConfigurationBuilder.cpp

@@ -15,13 +15,12 @@ SerializedMessage RobotConfigurationBuilder::build_robot_configuration(
     builder_.Clear();
 
     std::vector<flatbuffers::Offset<RobotModule>> module_vector;
-  std::vector<flatbuffers::Offset<Frontend::ModuleConnection>>
+    std::vector<flatbuffers::Offset<Frontend::ModuleConnection>> connection_vector;
-      connection_vector;
 
     for (const auto &connection : connections) {
         connection_vector.push_back(Frontend::CreateModuleConnection(
-        builder_, connection.from_module_id, connection.to_module_id,
+            builder_, connection.from_module_id, connection.to_module_id, connection.from_socket,
-        connection.from_socket, connection.to_socket, connection.orientation));
+            connection.to_socket, connection.orientation));
     }
 
     for (const auto &module : modules) {
@@ -29,15 +28,14 @@ SerializedMessage RobotConfigurationBuilder::build_robot_configuration(
         auto motor_state = CreateMotorState(builder_, module.angle);
         const flatbuffers::Offset<void> config_union = motor_state.Union();
         module_vector.push_back(CreateRobotModule(builder_, module.id, module.type,
-                                              ModuleState_MotorState,
+                                                  ModuleState_MotorState, config_union));
-                                              config_union));
     }
 
     const auto connection_vector_fb = builder_.CreateVector(connection_vector);
     const auto module_vector_fb = builder_.CreateVector(module_vector);
 
-  const auto message = Frontend::CreateRobotConfiguration(
+    const auto message =
-      builder_, module_vector_fb, connection_vector_fb);
+        Frontend::CreateRobotConfiguration(builder_, module_vector_fb, connection_vector_fb);
 
     builder_.Finish(message);
 
@@ -45,8 +43,7 @@ SerializedMessage RobotConfigurationBuilder::build_robot_configuration(
 }
 
 const Frontend::RobotConfiguration *
-RobotConfigurationBuilder::parse_robot_configuration(
+RobotConfigurationBuilder::parse_robot_configuration(const std::uint8_t *buffer) {
-    const std::uint8_t *buffer) {
     return flatbuffers::GetRoot<Frontend::RobotConfiguration>(buffer);
 }
 } // namespace Flatbuffers

src/flatbuffers/SensorMessageBuilder.cpp

@@ -3,8 +3,7 @@
 
 namespace Flatbuffers {
 
-const Messaging::SensorMessage *
+const Messaging::SensorMessage *SensorMessageBuilder::parse_sensor_message(const uint8_t *buffer) {
-SensorMessageBuilder::parse_sensor_message(const uint8_t *buffer) {
     return flatbuffers::GetRoot<Messaging::SensorMessage>(buffer);
 }
 

src/flatbuffers/TextControlMessageBuilder.cpp

@@ -6,13 +6,11 @@
 
 namespace Flatbuffers {
 
-SerializedMessage
+SerializedMessage TextControlMessageBuilder::build_text_control_message(std::string &t) {
-TextControlMessageBuilder::build_text_control_message(std::string &t) {
     builder_.Clear();
 
     auto text_offset = builder_.CreateString(t);
-  const auto message =
+    const auto message = Messaging::CreateTextControlMessage(builder_, text_offset);
-      Messaging::CreateTextControlMessage(builder_, text_offset);
 
     builder_.Finish(message);
 

src/flatbuffers/TopologyMessageBuilder.cpp

@@ -7,19 +7,18 @@
 #include "flatbuffers/SerializedMessage.h"
 
 namespace Flatbuffers {
-SerializedMessage TopologyMessageBuilder::build_topology_message(
+SerializedMessage
-    const uint8_t module_id, const ModuleType module_type,
+TopologyMessageBuilder::build_topology_message(const uint8_t module_id,
+                                               const ModuleType module_type,
                                                const std::vector<uint8_t> &channel_to_module,
                                                const std::vector<int8_t> &orientation_to_module) {
     builder_.Clear();
 
-  const auto orientation_to_module_vector =
+    const auto orientation_to_module_vector = builder_.CreateVector(orientation_to_module);
-      builder_.CreateVector(orientation_to_module);
+    const auto channel_to_module_vector = builder_.CreateVector(channel_to_module);
-  const auto channel_to_module_vector =
-      builder_.CreateVector(channel_to_module);
 
-  const auto message = Messaging::CreateTopologyMessage(
+    const auto message =
-      builder_, module_id, module_type, channel_to_module.size(),
+        Messaging::CreateTopologyMessage(builder_, module_id, module_type, channel_to_module.size(),
                                          channel_to_module_vector, orientation_to_module_vector);
 
     builder_.Finish(message);
@@ -32,8 +31,7 @@ TopologyMessageBuilder::parse_topology_message(const uint8_t *buffer) {
     return flatbuffers::GetRoot<Messaging::TopologyMessage>(buffer);
 }
 
-bool TopologyMessageBuilder::is_valid_topology_message(const uint8_t *buffer,
+bool TopologyMessageBuilder::is_valid_topology_message(const uint8_t *buffer, size_t size) {
-                                                       size_t size) {
     flatbuffers::Verifier verifier(buffer, size);
     return Messaging::VerifyTopologyMessageBuffer(verifier);
 }

src/lib_c_control.cpp

@@ -14,18 +14,18 @@
 extern "C" {
 const auto robot_controller = std::make_unique<RobotController>();
 
-const auto acm_builder =
+const auto acm_builder = std::make_unique<Flatbuffers::AngleControlMessageBuilder>();
-    std::make_unique<Flatbuffers::AngleControlMessageBuilder>();
 
-const auto robot_configuration_builder =
+const auto robot_configuration_builder = std::make_unique<Flatbuffers::RobotConfigurationBuilder>();
-    std::make_unique<Flatbuffers::RobotConfigurationBuilder>();
 
 LIB_API void init() {
     spdlog::info("[c_control] Initializing");
     robot_controller->fetchDirectlyConnectedModules(false);
 }
 
-LIB_API void cleanup() { spdlog::info("[c_control] Cleanup"); }
+LIB_API void cleanup() {
+    spdlog::info("[c_control] Cleanup");
+}
 
 LIB_API int send_angle_control(int module_id, int angle) {
     if (const auto maybe_module = robot_controller->getModule(module_id)) {
@@ -48,14 +48,12 @@ LIB_API char *get_configuration(int *size_out) {
     }
 
     const auto [data, size] =
-      robot_configuration_builder->build_robot_configuration(modules_vec,
+        robot_configuration_builder->build_robot_configuration(modules_vec, connections_vec);
-                                                             connections_vec);
     *size_out = size;
     return reinterpret_cast<char *>(data);
 }
 
-LIB_API bool control_sentry_init(const char *dsn, const char *environment,
+LIB_API bool control_sentry_init(const char *dsn, const char *environment, const char *release) {
-                                 const char *release) {
     sentry_options_t *options = sentry_options_new();
     sentry_options_set_dsn(options, dsn);
     sentry_options_set_environment(options, environment);
@@ -66,10 +64,11 @@ LIB_API bool control_sentry_init(const char *dsn, const char *environment,
     return true;
 }
 
-LIB_API void control_sentry_shutdown(void) { sentry_close(); }
+LIB_API void control_sentry_shutdown(void) {
+    sentry_close();
+}
 
-LIB_API void control_sentry_set_app_info(const char *app_name,
+LIB_API void control_sentry_set_app_info(const char *app_name, const char *app_version,
-                                         const char *app_version,
                                          const char *build_number) {
     sentry_value_t app = sentry_value_new_object();
 
@@ -78,13 +77,11 @@ LIB_API void control_sentry_set_app_info(const char *app_name,
     }
 
     if (app_version && *app_version) {
-    sentry_value_set_by_key(app, "version",
+        sentry_value_set_by_key(app, "version", sentry_value_new_string(app_version));
-                            sentry_value_new_string(app_version));
     }
 
     if (build_number && *build_number) {
-    sentry_value_set_by_key(app, "build",
+        sentry_value_set_by_key(app, "build", sentry_value_new_string(build_number));
-                            sentry_value_new_string(build_number));
     }
 
     sentry_set_context("app", app);
@@ -92,15 +89,42 @@ LIB_API void control_sentry_set_app_info(const char *app_name,
     if (app_version && *app_version) {
         if (build_number && *build_number) {
             char release[256];
-      snprintf(release, sizeof(release), "%s@%s+%s",
+            snprintf(release, sizeof(release), "%s@%s+%s", app_name && *app_name ? app_name : "app",
-               app_name && *app_name ? app_name : "app", app_version,
+                     app_version, build_number);
-               build_number);
         } else {
             // Example: mygame@1.2.3
             char release[256];
-      snprintf(release, sizeof(release), "%s@%s",
+            snprintf(release, sizeof(release), "%s@%s", app_name && *app_name ? app_name : "app",
-               app_name && *app_name ? app_name : "app", app_version);
+                     app_version);
         }
     }
 }
 }
+
+LIB_API bool remote_call_c(uint8_t function_tag, uint8_t module, const uint8_t *params,
+                           uint16_t params_len, uint8_t *out_buffer, uint16_t out_buffer_capacity,
+                           uint16_t *out_bytes_written) {
+
+    if (!out_bytes_written)
+        return false;
+
+    *out_bytes_written = 0;
+
+    std::vector<uint8_t> vec(params, params + params_len);
+
+    auto result = robot_controller->remote_call(function_tag, module, vec);
+
+    if (!result.has_value())
+        return false;
+
+    const std::vector<uint8_t> &out = *result.value();
+
+    size_t needed = out.size();
+
+    if (!out_buffer || out_buffer_capacity < needed)
+        return false;
+
+    memcpy(out_buffer, out.data(), needed);
+
+    return true;
+}

src/libcontrol.cpp

@@ -52,8 +52,7 @@ std::vector<std::weak_ptr<Module>> RobotController::getModules() {
     return out;
 }
 
-std::vector<Flatbuffers::ModuleConnectionInstance>
+std::vector<Flatbuffers::ModuleConnectionInstance> RobotController::getConnections() {
-RobotController::getConnections() {
     std::vector<Flatbuffers::ModuleConnectionInstance> out;
     std::shared_lock lock(m_connection_lock);
 
@@ -74,8 +73,7 @@ std::vector<Flatbuffers::ModuleInstance> RobotController::getModuleList() {
     return out;
 }
 
-std::optional<std::weak_ptr<Module>>
+std::optional<std::weak_ptr<Module>> RobotController::getModule(uint8_t device_id) {
-RobotController::getModule(uint8_t device_id) {
     std::shared_lock lock(m_module_lock);
     if (m_id_to_module.contains(device_id)) {
         return m_id_to_module[device_id];
@@ -110,8 +108,8 @@ void RobotController::metadata_loop() {
     unsigned char buf[TOPOLOGY_BUFFER_SIZE];
     const auto builder = std::make_unique<Flatbuffers::TopologyMessageBuilder>();
     while (!m_stop_thread) {
-    if (auto result = m_messaging_interface->recv(buf, TOPOLOGY_BUFFER_SIZE,
+        if (auto result =
-                                                  TOPOLOGY_CMD_TAG)) {
+                m_messaging_interface->recv(buf, TOPOLOGY_BUFFER_SIZE, TOPOLOGY_CMD_TAG)) {
             const auto &[rx_size, from] = *result;
 
             flatbuffers::Verifier verifier(buf, rx_size);
@@ -119,16 +117,13 @@ void RobotController::metadata_loop() {
                 continue;
             }
 
-      const auto metadata =
+            const auto metadata = builder->parse_topology_message(reinterpret_cast<uint8_t *>(buf));
-          builder->parse_topology_message(reinterpret_cast<uint8_t *>(buf));
             std::unique_lock lock(m_module_lock);
             if (!m_id_to_module.contains(metadata->module_id())) {
-        spdlog::info("[Control] Creating module entry for {}",
+                spdlog::info("[Control] Creating module entry for {}", metadata->module_id());
-                     metadata->module_id());
                 m_id_to_module.insert(
                     {metadata->module_id(),
-             ModuleFactory::createModule(metadata->module_id(),
+                     ModuleFactory::createModule(metadata->module_id(), metadata->module_type(),
-                                         metadata->module_type(),
                                                  m_messaging_interface)});
             }
 
@@ -143,8 +138,8 @@ void RobotController::metadata_loop() {
                         .to_module_id = metadata->channel_to_module()->Get(i),
                         .from_socket = i,
                         .to_socket = 0,
-              .orientation = static_cast<Orientation>(
+                        .orientation =
-                  metadata->channel_to_orientation()->Get(i))});
+                            static_cast<Orientation>(metadata->channel_to_orientation()->Get(i))});
                 }
             }
 
@@ -162,8 +157,7 @@ void RobotController::transmit_loop() {
             auto out = module->get_actuation_message();
 
             if (out.size() > 0) {
-        m_messaging_interface->send(out.data(), out.size(), id,
+                m_messaging_interface->send(out.data(), out.size(), id, ACTUATOR_CMD_TAG, false);
-                                    ACTUATOR_CMD_TAG, false);
             }
         }
     }
@@ -221,8 +215,7 @@ void RobotController::sensor_loop() {
     unsigned char buf[SENSOR_BUFFER_SIZE];
     const auto builder = std::make_unique<Flatbuffers::SensorMessageBuilder>();
     while (!m_stop_thread) {
-    if (auto result = m_messaging_interface->recv(buf, SENSOR_BUFFER_SIZE,
+        if (auto result = m_messaging_interface->recv(buf, SENSOR_BUFFER_SIZE, SENSOR_CMD_TAG)) {
-                                                  SENSOR_CMD_TAG)) {
             const auto &[rx_size, from] = *result;
 
             flatbuffers::Verifier verifier(buf, rx_size);
@@ -232,8 +225,7 @@ void RobotController::sensor_loop() {
 
             const auto sensor_message =
                 builder->parse_sensor_message(reinterpret_cast<uint8_t *>(buf));
-      if (sensor_message->values()->size() !=
+            if (sensor_message->values()->size() != sensor_message->values_type()->size()) {
-          sensor_message->values_type()->size()) {
                 spdlog::error("[Control] Got a sensor message with different value "
                               "({}) and type ({}) sizes",
                               sensor_message->values()->size(),
@@ -247,10 +239,8 @@ void RobotController::sensor_loop() {
             }
 
             for (int i = 0; i < sensor_message->values()->size(); i++) {
-        if (auto maybe_value =
+                if (auto maybe_value = Flatbuffers::SensorMessageBuilder::build_sensor_value(
-                Flatbuffers::SensorMessageBuilder::build_sensor_value(
+                        static_cast<Messaging::SensorValue>(sensor_message->values_type()->Get(i)),
-                    static_cast<Messaging::SensorValue>(
-                        sensor_message->values_type()->Get(i)),
                         sensor_message->values()->Get(i))) {
                     m_id_to_module[from]->update_sensor_data(*maybe_value);
                 }
@@ -258,3 +248,9 @@ void RobotController::sensor_loop() {
         }
     }
 }
+
+std::optional<std::unique_ptr<std::vector<uint8_t>>>
+RobotController::remote_call(uint8_t function_tag, uint8_t module,
+                             const std::vector<uint8_t> &parameters) {
+    return m_messaging_interface->remote_call(function_tag, module, parameters);
+}