botchain/control
1
0
Fork 0
mirror of https://github.com/BotChain-Robots/control.git synced 2026-03-09 16:22:26 +01:00
Code Issues Packages Projects Releases Wiki Activity

Formatting, add remote calling to c library

Browse Source
This commit is contained in:
Johnathon Slightham
2026-02-18 09:18:26 -05:00
parent 0088a9070b
commit 376b0b5285
49 changed files with 1915 additions and 1593 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
examples/display/main.cpp
View File

@@ -1,6 +1,6 @@
#include <chrono>
#include <iostream>
#include <format>
#include <iostream>
#include <thread>
#include "libcontrol.h"
@@ -21,10 +21,10 @@ int main() {
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;

4
examples/rpc_call/CMakeLists.txt
View File

@@ -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

25
examples/rpc_call/flatbuffers/OTAPacketBuilder.cpp Normal file
View File

@@ -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

28
examples/rpc_call/include/flatbuffers/OTAPacketBuilder.h Normal file
View File

@@ -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

15
examples/rpc_call/include/flatbuffers/SerializedMessage.h Normal file
View File

@@ -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

115
examples/rpc_call/include/flatbuffers_generated/OTAPacket_generated.h Normal file
View File

@@ -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_

24
examples/rpc_call/include/rpc/RemoteDebugging.h Normal file
View File

@@ -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

38
examples/rpc_call/include/rpc/RemoteManagement.h Normal file
View File

@@ -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

48
examples/rpc_call/main.cpp
View File

@@ -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 =
messaging_interface->find_connected_modules(std::chrono::seconds(3));
// const auto modules = 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) {
std::cout << "Found ID " << (int)module << std::endl;
}
// for (const auto module : modules) {
// std::cout << "Found ID " << (int)module << std::endl;
// }
const auto function_tag = 100;
const auto module = 98;
std::string msg = "Hello world!";
std::vector<uint8_t> parameters(msg.begin(), msg.end());
auto maybe_return_value =
messaging_interface->remote_call(function_tag, module, parameters);
const auto robot_controller = std::make_shared<RobotController>();
robot_controller->fetchDirectlyConnectedModules(true);
std::this_thread::sleep_for(std::chrono::seconds(5));
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;
}
// const auto function_tag = 3;
// const auto module = 99;
// std::string msg = "Hello world!";
// 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) {
// 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;
}

23
examples/rpc_call/rpc/RemoteDebugging.cpp Normal file
View File

@@ -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 "";
}

98
examples/rpc_call/rpc/RemoteManagement.cpp Normal file
View File

@@ -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;
}

7
include/Hub.h
View File

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

8
include/Module.h
View File

@@ -26,10 +26,10 @@ public:
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,
Messaging::ConnectionType connection_type, uint8_t leader)
: m_device_id(device_id), m_module_type(module_type),
m_connection_type(connection_type), m_leader(leader) {};
Module(uint8_t device_id, ModuleType module_type, Messaging::ConnectionType connection_type,
uint8_t leader)
: m_device_id(device_id), m_module_type(module_type), m_connection_type(connection_type),
m_leader(leader) {};
std::vector<neighbour> get_neighbours();

7
include/actuators/Actuator.h
View File

@@ -12,11 +12,10 @@ class Actuator : public Module {
public:
explicit Actuator(uint8_t device_id) : Module(device_id) {};
Actuator(uint8_t device_id, ModuleType module_type)
: Module(device_id, module_type) {};
Actuator(uint8_t device_id, ModuleType module_type) : Module(device_id, module_type) {};
Actuator(uint8_t device_id, ModuleType module_type,
Messaging::ConnectionType connection_type, uint8_t leader)
Actuator(uint8_t device_id, ModuleType module_type, Messaging::ConnectionType connection_type,
uint8_t leader)
: Module(device_id, module_type, connection_type, leader) {};
protected:

13
include/actuators/BoundedPositionalActuator1D.h
View File

@@ -14,13 +14,12 @@
class BoundedPositionalActuator1D : public Actuator {
public:
BoundedPositionalActuator1D(uint8_t device_id, ModuleType type,
double max_value, double min_value,
double initial_position)
: Actuator(device_id, type), m_target_position(initial_position),
m_max_value(max_value), m_min_value(min_value),
acm_builder(
std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {}
BoundedPositionalActuator1D(uint8_t device_id, ModuleType type, double max_value,
double min_value, double initial_position)
: Actuator(device_id, type), m_target_position(initial_position), m_max_value(max_value),
m_min_value(min_value),
acm_builder(std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {
}
double get_position() override;
std::string get_text() override; // no-op

7
include/actuators/OledActuator.h
View File

@@ -16,8 +16,8 @@ class OledActuator : public Actuator {
public:
OledActuator(uint8_t device_id, ModuleType type)
: Actuator(device_id, type),
m_text_message_builder(
std::make_unique<Flatbuffers::TextControlMessageBuilder>()) {}
m_text_message_builder(std::make_unique<Flatbuffers::TextControlMessageBuilder>()) {
}
double get_position() override;
std::string get_text() override;
@@ -31,8 +31,7 @@ public:
private:
std::string m_current_text = "";
std::string m_target_text = "";
std::unique_ptr<Flatbuffers::TextControlMessageBuilder>
m_text_message_builder;
std::unique_ptr<Flatbuffers::TextControlMessageBuilder> m_text_message_builder;
};
#endif // CONTROL_OLEDACTUATOR_H

3
include/actuators/PositionalActuator1D.h
View File

@@ -16,8 +16,7 @@ class PositionalActuator1D final : public Actuator {
public:
PositionalActuator1D(uint8_t device_id, ModuleType type)
: Actuator(device_id, type),
m_acm_builder(
std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {};
m_acm_builder(std::make_unique<Flatbuffers::AngleControlMessageBuilder>()) {};
double get_position() override;
std::string get_text() override; // no-op

6
include/flatbuffers/AngleControlMessageBuilder.h
View File

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

7
include/flatbuffers/RobotConfigurationBuilder.h
View File

@@ -27,10 +27,11 @@ struct ModuleConnectionInstance {
class RobotConfigurationBuilder {
public:
RobotConfigurationBuilder() : builder_(1024) {}
RobotConfigurationBuilder() : builder_(1024) {
}
SerializedMessage build_robot_configuration(
const std::vector<ModuleInstance> &modules,
SerializedMessage
build_robot_configuration(const std::vector<ModuleInstance> &modules,
const std::vector<ModuleConnectionInstance> &connections);
static const Frontend::RobotConfiguration *

9
include/flatbuffers/SensorMessageBuilder.h
View File

@@ -28,14 +28,13 @@ typedef std::variant<target_angle, current_angle, current_text> sensor_value;
class SensorMessageBuilder {
public:
SensorMessageBuilder() : builder_(1024) {}
SensorMessageBuilder() : builder_(1024) {
}
static const Messaging::SensorMessage *
parse_sensor_message(const std::uint8_t *buffer);
static const Messaging::SensorMessage *parse_sensor_message(const std::uint8_t *buffer);
template <typename T>
static std::optional<sensor_value>
build_sensor_value(Messaging::SensorValue type, T value) {
static std::optional<sensor_value> build_sensor_value(Messaging::SensorValue type, T value) {
switch (type) {
case Messaging::SensorValue_TargetAngle: {
const Messaging::TargetAngle *target =

3
include/flatbuffers/TextControlMessageBuilder.h
View File

@@ -15,7 +15,8 @@
namespace Flatbuffers {
class TextControlMessageBuilder {
public:
TextControlMessageBuilder() : builder_(256) {}
TextControlMessageBuilder() : builder_(256) {
}
SerializedMessage build_text_control_message(std::string &t);

9
include/flatbuffers/TopologyMessageBuilder.h
View File

@@ -13,15 +13,14 @@
namespace Flatbuffers {
class TopologyMessageBuilder {
public:
TopologyMessageBuilder() : builder_(1024) {}
TopologyMessageBuilder() : builder_(1024) {
}
SerializedMessage
build_topology_message(uint8_t module_id, ModuleType module_type,
SerializedMessage 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 *
parse_topology_message(const uint8_t *buffer);
static const Messaging::TopologyMessage *parse_topology_message(const uint8_t *buffer);
static bool is_valid_topology_message(const uint8_t *buffer, size_t size);

40
include/flatbuffers_generated/AngleControlMessage_generated.h
View File

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

104
include/flatbuffers_generated/RobotConfiguration_generated.h
View File

@@ -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 from_socket() const { return GetField<uint8_t>(VT_FROM_SOCKET, 0); }
uint8_t to_socket() const { return GetField<uint8_t>(VT_TO_SOCKET, 0); }
uint8_t to_module_id() const {
return GetField<uint8_t>(VT_TO_MODULE_ID, 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) &&
VerifyField<uint8_t>(verifier, VT_FROM_MODULE_ID, 1) &&
return VerifyTableStart(verifier) && 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) &&
verifier.EndTable();
VerifyField<int8_t>(verifier, VT_ORIENTATION, 1) && 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,
from_module_id, 0);
fbb_.AddElement<uint8_t>(ModuleConnection::VT_FROM_MODULE_ID, 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,
0);
fbb_.AddElement<uint8_t>(ModuleConnection::VT_TO_MODULE_ID, to_module_id, 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,
static_cast<int8_t>(orientation), 0);
fbb_.AddElement<int8_t>(ModuleConnection::VT_ORIENTATION, static_cast<int8_t>(orientation),
0);
}
explicit ModuleConnectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
explicit ModuleConnectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ModuleConnection> Finish() {
@@ -85,9 +86,8 @@ struct ModuleConnectionBuilder {
};
inline ::flatbuffers::Offset<ModuleConnection>
CreateModuleConnection(::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t from_module_id = 0, uint8_t to_module_id = 0,
uint8_t from_socket = 0, uint8_t to_socket = 0,
CreateModuleConnection(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t from_module_id = 0,
uint8_t to_module_id = 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
: private ::flatbuffers::Table {
struct RobotConfiguration FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RobotConfigurationBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MODULES = 4,
VT_CONNECTIONS = 6
};
const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *
modules() const {
return GetPointer<
const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *>(
const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *modules() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *>(
VT_MODULES);
}
const ::flatbuffers::Vector<
::flatbuffers::Offset<Frontend::ModuleConnection>> *
const ::flatbuffers::Vector<::flatbuffers::Offset<Frontend::ModuleConnection>> *
connections() const {
return GetPointer<const ::flatbuffers::Vector<
::flatbuffers::Offset<Frontend::ModuleConnection>> *>(VT_CONNECTIONS);
return GetPointer<
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.VerifyVectorOfTables(modules()) &&
VerifyOffset(verifier, VT_CONNECTIONS) &&
verifier.VerifyVector(connections()) &&
verifier.VerifyVector(modules()) && verifier.VerifyVectorOfTables(modules()) &&
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<
::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>>
modules) {
void add_modules(
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>> modules) {
fbb_.AddOffset(RobotConfiguration::VT_MODULES, modules);
}
void add_connections(::flatbuffers::Offset<::flatbuffers::Vector<
::flatbuffers::Offset<Frontend::ModuleConnection>>>
void add_connections(::flatbuffers::Offset<
::flatbuffers::Vector<::flatbuffers::Offset<Frontend::ModuleConnection>>>
connections) {
fbb_.AddOffset(RobotConfiguration::VT_CONNECTIONS, connections);
}
explicit RobotConfigurationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
explicit RobotConfigurationBuilder(::flatbuffers::FlatBufferBuilder &_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::Vector<::flatbuffers::Offset<RobotModule>>>
modules = 0,
::flatbuffers::Offset<::flatbuffers::Vector<
::flatbuffers::Offset<Frontend::ModuleConnection>>>
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>> 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>>
*connections = nullptr) {
auto modules__ =
modules ? _fbb.CreateVector<::flatbuffers::Offset<RobotModule>>(*modules)
: 0;
const std::vector<::flatbuffers::Offset<Frontend::ModuleConnection>> *connections = nullptr) {
auto modules__ = modules ? _fbb.CreateVector<::flatbuffers::Offset<RobotModule>>(*modules) : 0;
auto connections__ =
connections
? _fbb.CreateVector<
::flatbuffers::Offset<Frontend::ModuleConnection>>(*connections)
? _fbb.CreateVector<::flatbuffers::Offset<Frontend::ModuleConnection>>(*connections)
: 0;
return Frontend::CreateRobotConfiguration(_fbb, modules__, connections__);
}
inline const Frontend::RobotConfiguration *
GetRobotConfiguration(const void *buf) {
inline const Frontend::RobotConfiguration *GetRobotConfiguration(const void *buf) {
return ::flatbuffers::GetRoot<Frontend::RobotConfiguration>(buf);
}
inline const Frontend::RobotConfiguration *
GetSizePrefixedRobotConfiguration(const void *buf) {
inline const Frontend::RobotConfiguration *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
VerifySizePrefixedRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Frontend::RobotConfiguration>(
nullptr);
inline bool VerifySizePrefixedRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Frontend::RobotConfiguration>(nullptr);
}
inline void FinishRobotConfigurationBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
inline void
FinishRobotConfigurationBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Frontend::RobotConfiguration> root) {
fbb.Finish(root);
}

78
include/flatbuffers_generated/RobotModule_generated.h
View File

@@ -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",
"DISPLAY", "GRIPPER", "SPEAKER", "IMU", "DISTANCE_SENSOR",
"SPLITTER_2", "SPLITTER_3", "SPLITTER_4", "SPLITTER_5", "SPLITTER_6",
"SPLITTER_7", "SPLITTER_8", nullptr};
"SPLITTER", "SERVO_1", "DC_MOTOR", "BATTERY", "SERVO_2", "DISPLAY",
"GRIPPER", "SPEAKER", "IMU", "DISTANCE_SENSOR", "SPLITTER_2", "SPLITTER_3",
"SPLITTER_4", "SPLITTER_5", "SPLITTER_6", "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,
Orientation_Deg180, Orientation_Deg270};
static const Orientation values[] = {Orientation_Deg0, Orientation_Deg90, Orientation_Deg180,
Orientation_Deg270};
return values;
}
inline const char *const *EnumNamesOrientation() {
static const char *const names[5] = {"Deg0", "Deg90", "Deg180", "Deg270",
nullptr};
static const char *const names[5] = {"Deg0", "Deg90", "Deg180", "Deg270", nullptr};
return names;
}
@@ -103,8 +101,7 @@ enum ModuleState : uint8_t {
};
inline const ModuleState (&EnumValuesModuleState())[2] {
static const ModuleState values[] = {ModuleState_NONE,
ModuleState_MotorState};
static const ModuleState values[] = {ModuleState_NONE, 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,
ModuleState type);
bool VerifyModuleStateVector(
::flatbuffers::Verifier &verifier,
bool VerifyModuleState(::flatbuffers::Verifier &verifier, const void *obj, ModuleState type);
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 {
VT_ANGLE = 4
};
int32_t angle() const { return GetField<int32_t>(VT_ANGLE, 0); }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ANGLE = 4 };
int32_t angle() const {
return GetField<int32_t>(VT_ANGLE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_ANGLE, 4) && verifier.EndTable();
return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_ANGLE, 4) &&
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)
: fbb_(_fbb) {
explicit MotorStateBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MotorState> Finish() {
@@ -165,8 +159,8 @@ struct MotorStateBuilder {
}
};
inline ::flatbuffers::Offset<MotorState>
CreateMotorState(::flatbuffers::FlatBufferBuilder &_fbb, int32_t angle = 0) {
inline ::flatbuffers::Offset<MotorState> CreateMotorState(::flatbuffers::FlatBufferBuilder &_fbb,
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>(
GetField<uint8_t>(VT_CONFIGURATION_TYPE, 0));
return static_cast<ModuleState>(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) &&
VerifyField<uint8_t>(verifier, VT_ID, 1) &&
return VerifyTableStart(verifier) && 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 <>
inline const MotorState *RobotModule::configuration_as<MotorState>() const {
template <> 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,
static_cast<int8_t>(module_type), 0);
fbb_.AddElement<int8_t>(RobotModule::VT_MODULE_TYPE, 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)
: fbb_(_fbb) {
explicit RobotModuleBuilder(::flatbuffers::FlatBufferBuilder &_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,
const void *obj, ModuleState type) {
inline bool VerifyModuleState(::flatbuffers::Verifier &verifier, const void *obj,
ModuleState type) {
switch (type) {
case ModuleState_NONE: {
return true;
@@ -270,8 +261,8 @@ inline bool VerifyModuleState(::flatbuffers::Verifier &verifier,
}
}
inline bool VerifyModuleStateVector(
::flatbuffers::Verifier &verifier,
inline bool
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),
types->GetEnum<ModuleState>(i))) {
if (!VerifyModuleState(verifier, values->Get(i), types->GetEnum<ModuleState>(i))) {
return false;
}
}
@@ -299,8 +289,7 @@ inline bool VerifyRobotModuleBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<RobotModule>(nullptr);
}
inline bool
VerifySizePrefixedRobotModuleBuffer(::flatbuffers::Verifier &verifier) {
inline bool VerifySizePrefixedRobotModuleBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<RobotModule>(nullptr);
}
@@ -309,8 +298,7 @@ inline void FinishRobotModuleBuffer(::flatbuffers::FlatBufferBuilder &fbb,
fbb.Finish(root);
}
inline void
FinishSizePrefixedRobotModuleBuffer(::flatbuffers::FlatBufferBuilder &fbb,
inline void FinishSizePrefixedRobotModuleBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<RobotModule> root) {
fbb.FinishSizePrefixed(root);
}

119
include/flatbuffers_generated/SensorMessage_generated.h
View File

@@ -36,15 +36,14 @@ enum SensorValue : uint8_t {
};
inline const SensorValue (&EnumValuesSensorValue())[4] {
static const SensorValue values[] = {
SensorValue_NONE, SensorValue_TargetAngle, SensorValue_CurrentAngle,
SensorValue_CurrentText};
static const SensorValue values[] = {SensorValue_NONE, SensorValue_TargetAngle,
SensorValue_CurrentAngle, SensorValue_CurrentText};
return values;
}
inline const char *const *EnumNamesSensorValue() {
static const char *const names[5] = {"NONE", "TargetAngle", "CurrentAngle",
"CurrentText", nullptr};
static const char *const names[5] = {"NONE", "TargetAngle", "CurrentAngle", "CurrentText",
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,
SensorValue type);
bool VerifySensorValueVector(
::flatbuffers::Verifier &verifier,
bool VerifySensorValue(::flatbuffers::Verifier &verifier, const void *obj, SensorValue type);
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 {
VT_VALUE = 4
};
int16_t value() const { return GetField<int16_t>(VT_VALUE, 0); }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 };
int16_t value() const {
return GetField<int16_t>(VT_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int16_t>(verifier, VT_VALUE, 2) && verifier.EndTable();
return VerifyTableStart(verifier) && VerifyField<int16_t>(verifier, VT_VALUE, 2) &&
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)
: fbb_(_fbb) {
explicit TargetAngleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TargetAngle> Finish() {
@@ -108,8 +104,8 @@ struct TargetAngleBuilder {
}
};
inline ::flatbuffers::Offset<TargetAngle>
CreateTargetAngle(::flatbuffers::FlatBufferBuilder &_fbb, int16_t value = 0) {
inline ::flatbuffers::Offset<TargetAngle> CreateTargetAngle(::flatbuffers::FlatBufferBuilder &_fbb,
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 {
VT_VALUE = 4
};
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 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)
: fbb_(_fbb) {
explicit CurrentTextBuilder(::flatbuffers::FlatBufferBuilder &_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,
const char *value = nullptr) {
CreateCurrentTextDirect(::flatbuffers::FlatBufferBuilder &_fbb, 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 {
VT_VALUE = 4
};
int16_t value() const { return GetField<int16_t>(VT_VALUE, 0); }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 };
int16_t value() const {
return GetField<int16_t>(VT_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int16_t>(verifier, VT_VALUE, 2) && verifier.EndTable();
return VerifyTableStart(verifier) && VerifyField<int16_t>(verifier, VT_VALUE, 2) &&
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)
: fbb_(_fbb) {
explicit CurrentAngleBuilder(::flatbuffers::FlatBufferBuilder &_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<
const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_VALUES);
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_VALUES);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VALUES_TYPE) &&
verifier.VerifyVector(values_type()) &&
VerifyOffset(verifier, VT_VALUES) &&
return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES_TYPE) &&
verifier.VerifyVector(values_type()) && VerifyOffset(verifier, VT_VALUES) &&
verifier.VerifyVector(values()) &&
VerifySensorValueVector(verifier, values(), values_type()) &&
verifier.EndTable();
VerifySensorValueVector(verifier, values(), values_type()) && verifier.EndTable();
}
};
@@ -227,17 +214,14 @@ struct SensorMessageBuilder {
typedef SensorMessage Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_values_type(
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values_type) {
void add_values_type(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values_type) {
fbb_.AddOffset(SensorMessage::VT_VALUES_TYPE, values_type);
}
void add_values(
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>>
values) {
void
add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> values) {
fbb_.AddOffset(SensorMessage::VT_VALUES, values);
}
explicit SensorMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
explicit SensorMessageBuilder(::flatbuffers::FlatBufferBuilder &_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>>>
values = 0) {
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> values = 0) {
SensorMessageBuilder builder_(_fbb);
builder_.add_values(values);
builder_.add_values_type(values_type);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SensorMessage> CreateSensorMessageDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<SensorMessage>
CreateSensorMessageDirect(::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *values_type = nullptr,
const std::vector<::flatbuffers::Offset<void>> *values = nullptr) {
auto values_type__ =
values_type ? _fbb.CreateVector<uint8_t>(*values_type) : 0;
auto values__ =
values ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*values) : 0;
auto values_type__ = values_type ? _fbb.CreateVector<uint8_t>(*values_type) : 0;
auto values__ = values ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*values) : 0;
return Messaging::CreateSensorMessage(_fbb, values_type__, values__);
}
inline bool VerifySensorValue(::flatbuffers::Verifier &verifier,
const void *obj, SensorValue type) {
inline bool VerifySensorValue(::flatbuffers::Verifier &verifier, const void *obj,
SensorValue type) {
switch (type) {
case SensorValue_NONE: {
return true;
@@ -292,8 +273,8 @@ inline bool VerifySensorValue(::flatbuffers::Verifier &verifier,
}
}
inline bool VerifySensorValueVector(
::flatbuffers::Verifier &verifier,
inline bool
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),
types->GetEnum<SensorValue>(i))) {
if (!VerifySensorValue(verifier, values->Get(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 *
GetSizePrefixedSensorMessage(const void *buf) {
inline const Messaging::SensorMessage *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
VerifySizePrefixedSensorMessageBuffer(::flatbuffers::Verifier &verifier) {
inline bool VerifySizePrefixedSensorMessageBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::SensorMessage>(nullptr);
}
inline void FinishSensorMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
inline void FinishSensorMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::SensorMessage> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedSensorMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
inline void
FinishSizePrefixedSensorMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::SensorMessage> root) {
fbb.FinishSizePrefixed(root);
}

30
include/flatbuffers_generated/TextControlMessage_generated.h
View File

@@ -17,12 +17,9 @@ namespace Messaging {
struct TextControlMessage;
struct TextControlMessageBuilder;
struct TextControlMessage FLATBUFFERS_FINAL_CLASS
: private ::flatbuffers::Table {
struct TextControlMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TextControlMessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MESSAGE = 4
};
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 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)
: fbb_(_fbb) {
explicit TextControlMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TextControlMessage> Finish() {
@@ -50,8 +46,8 @@ struct TextControlMessageBuilder {
}
};
inline ::flatbuffers::Offset<TextControlMessage> CreateTextControlMessage(
::flatbuffers::FlatBufferBuilder &_fbb,
inline ::flatbuffers::Offset<TextControlMessage>
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 *
GetTextControlMessage(const void *buf) {
inline const Messaging::TextControlMessage *GetTextControlMessage(const void *buf) {
return ::flatbuffers::GetRoot<Messaging::TextControlMessage>(buf);
}
inline const Messaging::TextControlMessage *
GetSizePrefixedTextControlMessage(const void *buf) {
inline const Messaging::TextControlMessage *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
VerifySizePrefixedTextControlMessageBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::TextControlMessage>(
nullptr);
inline bool VerifySizePrefixedTextControlMessageBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::TextControlMessage>(nullptr);
}
inline void FinishTextControlMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
inline void
FinishTextControlMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::TextControlMessage> root) {
fbb.Finish(root);
}

84
include/flatbuffers_generated/TopologyMessage_generated.h
View File

@@ -27,8 +27,7 @@ enum ConnectionType : int8_t {
};
inline const ConnectionType (&EnumValuesConnectionType())[2] {
static const ConnectionType values[] = {ConnectionType_DIRECT,
ConnectionType_HOP};
static const ConnectionType values[] = {ConnectionType_DIRECT, 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> *>(
VT_CHANNEL_TO_MODULE);
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CHANNEL_TO_MODULE);
}
const ::flatbuffers::Vector<int8_t> *channel_to_orientation() const {
return GetPointer<const ::flatbuffers::Vector<int8_t> *>(
VT_CHANNEL_TO_ORIENTATION);
return GetPointer<const ::flatbuffers::Vector<int8_t> *>(VT_CHANNEL_TO_ORIENTATION);
}
Messaging::ConnectionType connection() const {
return static_cast<Messaging::ConnectionType>(
GetField<int8_t>(VT_CONNECTION, 0));
return static_cast<Messaging::ConnectionType>(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) &&
VerifyField<uint8_t>(verifier, VT_MODULE_ID, 1) &&
return VerifyTableStart(verifier) && 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) &&
verifier.VerifyString(firmware()) && verifier.EndTable();
VerifyOffset(verifier, VT_FIRMWARE) && verifier.VerifyString(firmware()) &&
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,
static_cast<int8_t>(module_type), 0);
fbb_.AddElement<int8_t>(TopologyMessage::VT_MODULE_TYPE, static_cast<int8_t>(module_type),
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(
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> channel_to_module) {
void
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>>
channel_to_orientation) {
fbb_.AddOffset(TopologyMessage::VT_CHANNEL_TO_ORIENTATION,
channel_to_orientation);
::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> 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,
static_cast<int8_t>(connection), 0);
fbb_.AddElement<int8_t>(TopologyMessage::VT_CONNECTION, 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)
: fbb_(_fbb) {
explicit TopologyMessageBuilder(::flatbuffers::FlatBufferBuilder &_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>>
channel_to_orientation = 0,
Messaging::ConnectionType connection = Messaging::ConnectionType_DIRECT,
uint8_t leader = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> channel_to_orientation = 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(
::flatbuffers::FlatBufferBuilder &_fbb, uint8_t module_id = 0,
inline ::flatbuffers::Offset<TopologyMessage>
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
? _fbb.CreateVector<int8_t>(*channel_to_orientation)
: 0;
channel_to_orientation ? _fbb.CreateVector<int8_t>(*channel_to_orientation) : 0;
auto firmware__ = firmware ? _fbb.CreateString(firmware) : 0;
return Messaging::CreateTopologyMessage(
_fbb, module_id, module_type, num_channels, channel_to_module__,
channel_to_orientation__, connection, leader, firmware__);
return Messaging::CreateTopologyMessage(_fbb, module_id, module_type, num_channels,
channel_to_module__, channel_to_orientation__,
connection, leader, firmware__);
}
inline const Messaging::TopologyMessage *GetTopologyMessage(const void *buf) {
return ::flatbuffers::GetRoot<Messaging::TopologyMessage>(buf);
}
inline const Messaging::TopologyMessage *
GetSizePrefixedTopologyMessage(const void *buf) {
inline const Messaging::TopologyMessage *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
VerifySizePrefixedTopologyMessageBuffer(::flatbuffers::Verifier &verifier) {
inline bool VerifySizePrefixedTopologyMessageBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::TopologyMessage>(nullptr);
}
inline void FinishTopologyMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
inline void FinishTopologyMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::TopologyMessage> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedTopologyMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
inline void
FinishSizePrefixedTopologyMessageBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::TopologyMessage> root) {
fbb.FinishSizePrefixed(root);
}

12
include/lib_c_control.h
View File

@@ -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,
const char *release);
LIB_API void control_sentry_set_app_info(const char *app_name,
const char *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);
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);
}

9
include/libcontrol.h
View File

@@ -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(
std::thread(&RobotController::configuration_loop, this)),
m_configuration_loop(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);
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::vector<Flatbuffers::ModuleConnectionInstance>>
std::unordered_map<uint8_t, std::vector<Flatbuffers::ModuleConnectionInstance>>
m_connection_map{};
std::shared_mutex m_module_lock{};
std::shared_mutex m_connection_lock{};

7
include/util/Event.h
View File

@@ -8,7 +8,8 @@ class Event;
class CallbackHandle {
public:
CallbackHandle(Event *evt, int id) : evt(evt), id(id) {}
CallbackHandle(Event *evt, int id) : evt(evt), id(id) {
}
~CallbackHandle();
private:
@@ -26,7 +27,9 @@ 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)

23
src/Module.cpp
View File

@@ -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>
Module::get_last_updated_time() {
std::chrono::time_point<std::chrono::system_clock> 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(),
*message.channel_to_orientation())) {
for (auto [id, ori] :
std::views::zip(*message.channel_to_module(), *message.channel_to_orientation())) {
m_neighbours.emplace_back(neighbour{id, static_cast<Orientation>(ori)});
}
}

7
src/ModuleFactory.cpp
View File

@@ -10,8 +10,8 @@
#define SERVO1_MIN_ANGLE 0
#define SERVO1_DEFAULT_ANGLE 90
std::shared_ptr<Module> ModuleFactory::createModule(
uint8_t device_id, ModuleType type,
std::shared_ptr<Module>
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,
SERVO1_DEFAULT_ANGLE);
device_id, type, SERVO1_MAX_ANGLE, SERVO1_MIN_ANGLE, SERVO1_DEFAULT_ANGLE);
case ModuleType_DC_MOTOR:
return std::make_shared<PositionalActuator1D>(device_id, type);
case ModuleType_DISPLAY:

23
src/actuators/BoundedPositionalActuator1D.cpp
View File

@@ -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] =
acm_builder->build_angle_control_message(m_target_position);
auto [data, size] = acm_builder->build_angle_control_message(m_target_position);
message.resize(size);
memcpy(message.data(), data, size);
return message;
}
void BoundedPositionalActuator1D::update_sensor_data(
const Flatbuffers::sensor_value &value) {
std::visit(
overloaded{
void BoundedPositionalActuator1D::update_sensor_data(const Flatbuffers::sensor_value &value) {
std::visit(overloaded{
[this](Flatbuffers::target_angle a) { m_current_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);

24
src/actuators/OledActuator.cpp
View File

@@ -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] =
m_text_message_builder->build_text_control_message(m_target_text);
auto [data, size] = 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(
overloaded{
std::visit(overloaded{
[this](Flatbuffers::target_angle /* a */) {},
[this](Flatbuffers::current_angle /* a */) {},
[this](Flatbuffers::current_text t) { m_current_text = t.text; },

28
src/actuators/PositionalActuator1D.cpp
View File

@@ -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] =
m_acm_builder->build_angle_control_message(m_target_position);
auto [data, size] = 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(
const Flatbuffers::sensor_value &value) {
void PositionalActuator1D::update_sensor_data(const Flatbuffers::sensor_value &value) {
std::visit(overloaded{
[this](Flatbuffers::target_angle a) {
m_board_target_position = a.angle;
},
[this](Flatbuffers::current_angle a) {
m_current_position = a.angle;
},
[this](Flatbuffers::target_angle a) { m_board_target_position = a.angle; },
[this](Flatbuffers::current_angle a) { m_current_position = a.angle; },
[this](Flatbuffers::current_text /*t*/) {},
},
value);

3
src/flatbuffers/AngleControlMessageBuilder.cpp
View File

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

17
src/flatbuffers/RobotConfigurationBuilder.cpp
View File

@@ -15,13 +15,12 @@ SerializedMessage RobotConfigurationBuilder::build_robot_configuration(
builder_.Clear();
std::vector<flatbuffers::Offset<RobotModule>> module_vector;
std::vector<flatbuffers::Offset<Frontend::ModuleConnection>>
connection_vector;
std::vector<flatbuffers::Offset<Frontend::ModuleConnection>> connection_vector;
for (const auto &connection : connections) {
connection_vector.push_back(Frontend::CreateModuleConnection(
builder_, connection.from_module_id, connection.to_module_id,
connection.from_socket, connection.to_socket, connection.orientation));
builder_, connection.from_module_id, connection.to_module_id, connection.from_socket,
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,
config_union));
ModuleState_MotorState, 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(
builder_, module_vector_fb, connection_vector_fb);
const auto message =
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(
const std::uint8_t *buffer) {
RobotConfigurationBuilder::parse_robot_configuration(const std::uint8_t *buffer) {
return flatbuffers::GetRoot<Frontend::RobotConfiguration>(buffer);
}
} // namespace Flatbuffers

3
src/flatbuffers/SensorMessageBuilder.cpp
View File

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

6
src/flatbuffers/TextControlMessageBuilder.cpp
View File

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

18
src/flatbuffers/TopologyMessageBuilder.cpp
View File

@@ -7,19 +7,18 @@
#include "flatbuffers/SerializedMessage.h"
namespace Flatbuffers {
SerializedMessage TopologyMessageBuilder::build_topology_message(
const uint8_t module_id, const ModuleType module_type,
SerializedMessage
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 =
builder_.CreateVector(orientation_to_module);
const auto channel_to_module_vector =
builder_.CreateVector(channel_to_module);
const auto orientation_to_module_vector = builder_.CreateVector(orientation_to_module);
const auto channel_to_module_vector = builder_.CreateVector(channel_to_module);
const auto message = Messaging::CreateTopologyMessage(
builder_, module_id, module_type, channel_to_module.size(),
const auto message =
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,
size_t size) {
bool TopologyMessageBuilder::is_valid_topology_message(const uint8_t *buffer, size_t size) {
flatbuffers::Verifier verifier(buffer, size);
return Messaging::VerifyTopologyMessageBuffer(verifier);
}

66
src/lib_c_control.cpp
View File

@@ -14,18 +14,18 @@
extern "C" {
const auto robot_controller = std::make_unique<RobotController>();
const auto acm_builder =
std::make_unique<Flatbuffers::AngleControlMessageBuilder>();
const auto acm_builder = std::make_unique<Flatbuffers::AngleControlMessageBuilder>();
const auto robot_configuration_builder =
std::make_unique<Flatbuffers::RobotConfigurationBuilder>();
const auto robot_configuration_builder = 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,
connections_vec);
robot_configuration_builder->build_robot_configuration(modules_vec, connections_vec);
*size_out = size;
return reinterpret_cast<char *>(data);
}
LIB_API bool control_sentry_init(const char *dsn, const char *environment,
const char *release) {
LIB_API bool control_sentry_init(const char *dsn, const char *environment, 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,
const char *app_version,
LIB_API void control_sentry_set_app_info(const char *app_name, 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_new_string(app_version));
sentry_value_set_by_key(app, "version", sentry_value_new_string(app_version));
}
if (build_number && *build_number) {
sentry_value_set_by_key(app, "build",
sentry_value_new_string(build_number));
sentry_value_set_by_key(app, "build", 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",
app_name && *app_name ? app_name : "app", app_version,
build_number);
snprintf(release, sizeof(release), "%s@%s+%s", app_name && *app_name ? app_name : "app",
app_version, build_number);
} else {
// Example: mygame@1.2.3
char release[256];
snprintf(release, sizeof(release), "%s@%s",
app_name && *app_name ? app_name : "app", app_version);
snprintf(release, sizeof(release), "%s@%s", app_name && *app_name ? app_name : "app",
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;
}

44
src/libcontrol.cpp
View File

@@ -52,8 +52,7 @@ std::vector<std::weak_ptr<Module>> RobotController::getModules() {
return out;
}
std::vector<Flatbuffers::ModuleConnectionInstance>
RobotController::getConnections() {
std::vector<Flatbuffers::ModuleConnectionInstance> 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>>
RobotController::getModule(uint8_t device_id) {
std::optional<std::weak_ptr<Module>> 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,
TOPOLOGY_CMD_TAG)) {
if (auto result =
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 =
builder->parse_topology_message(reinterpret_cast<uint8_t *>(buf));
const auto metadata = 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 {}",
metadata->module_id());
spdlog::info("[Control] Creating module entry for {}", metadata->module_id());
m_id_to_module.insert(
{metadata->module_id(),
ModuleFactory::createModule(metadata->module_id(),
metadata->module_type(),
ModuleFactory::createModule(metadata->module_id(), 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>(
metadata->channel_to_orientation()->Get(i))});
.orientation =
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,
ACTUATOR_CMD_TAG, false);
m_messaging_interface->send(out.data(), out.size(), id, 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,
SENSOR_CMD_TAG)) {
if (auto result = m_messaging_interface->recv(buf, SENSOR_BUFFER_SIZE, 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() !=
sensor_message->values_type()->size()) {
if (sensor_message->values()->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 =
Flatbuffers::SensorMessageBuilder::build_sensor_value(
static_cast<Messaging::SensorValue>(
sensor_message->values_type()->Get(i)),
if (auto maybe_value = Flatbuffers::SensorMessageBuilder::build_sensor_value(
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);
}