botchain/firmware
1
0
Fork 0
mirror of https://github.com/BotChain-Robots/firmware.git synced 2026-07-08 17:47:21 +02:00
Code Issues Packages Projects Releases Wiki Activity

Board to PC

Browse Source
This commit is contained in:
Johnathon Slightham
2025-07-12 14:13:11 -04:00
parent c57fbd53e7
commit ab277d05a0
9 changed files with 139 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

634
components/flatbuffers/include/flatbuffers_generated/ConfigMessage_generated.h
View File

@@ -1,634 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_CONFIGMESSAGE_MESSAGING_H_
#define FLATBUFFERS_GENERATED_CONFIGMESSAGE_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 I32Value;
struct I32ValueBuilder;
struct U32Value;
struct U32ValueBuilder;
struct I64Value;
struct I64ValueBuilder;
struct U64Value;
struct U64ValueBuilder;
struct StringValue;
struct StringValueBuilder;
struct BlobValue;
struct BlobValueBuilder;
struct ConfigMessage;
struct ConfigMessageBuilder;
enum EntryType : int8_t {
EntryType_NONE = 0,
EntryType_I32 = 1,
EntryType_U32 = 2,
EntryType_I64 = 3,
EntryType_U64 = 4,
EntryType_STRING = 5,
EntryType_BLOB = 6,
EntryType_MIN = EntryType_NONE,
EntryType_MAX = EntryType_BLOB
};
inline const EntryType (&EnumValuesEntryType())[7] {
static const EntryType values[] = {
EntryType_NONE,
EntryType_I32,
EntryType_U32,
EntryType_I64,
EntryType_U64,
EntryType_STRING,
EntryType_BLOB
};
return values;
}
inline const char * const *EnumNamesEntryType() {
static const char * const names[8] = {
"NONE",
"I32",
"U32",
"I64",
"U64",
"STRING",
"BLOB",
nullptr
};
return names;
}
inline const char *EnumNameEntryType(EntryType e) {
if (::flatbuffers::IsOutRange(e, EntryType_NONE, EntryType_BLOB)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesEntryType()[index];
}
enum NvsValue : uint8_t {
NvsValue_NONE = 0,
NvsValue_I32Value = 1,
NvsValue_U32Value = 2,
NvsValue_I64Value = 3,
NvsValue_U64Value = 4,
NvsValue_StringValue = 5,
NvsValue_BlobValue = 6,
NvsValue_MIN = NvsValue_NONE,
NvsValue_MAX = NvsValue_BlobValue
};
inline const NvsValue (&EnumValuesNvsValue())[7] {
static const NvsValue values[] = {
NvsValue_NONE,
NvsValue_I32Value,
NvsValue_U32Value,
NvsValue_I64Value,
NvsValue_U64Value,
NvsValue_StringValue,
NvsValue_BlobValue
};
return values;
}
inline const char * const *EnumNamesNvsValue() {
static const char * const names[8] = {
"NONE",
"I32Value",
"U32Value",
"I64Value",
"U64Value",
"StringValue",
"BlobValue",
nullptr
};
return names;
}
inline const char *EnumNameNvsValue(NvsValue e) {
if (::flatbuffers::IsOutRange(e, NvsValue_NONE, NvsValue_BlobValue)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesNvsValue()[index];
}
template<typename T> struct NvsValueTraits {
static const NvsValue enum_value = NvsValue_NONE;
};
template<> struct NvsValueTraits<Messaging::I32Value> {
static const NvsValue enum_value = NvsValue_I32Value;
};
template<> struct NvsValueTraits<Messaging::U32Value> {
static const NvsValue enum_value = NvsValue_U32Value;
};
template<> struct NvsValueTraits<Messaging::I64Value> {
static const NvsValue enum_value = NvsValue_I64Value;
};
template<> struct NvsValueTraits<Messaging::U64Value> {
static const NvsValue enum_value = NvsValue_U64Value;
};
template<> struct NvsValueTraits<Messaging::StringValue> {
static const NvsValue enum_value = NvsValue_StringValue;
};
template<> struct NvsValueTraits<Messaging::BlobValue> {
static const NvsValue enum_value = NvsValue_BlobValue;
};
bool VerifyNvsValue(::flatbuffers::Verifier &verifier, const void *obj, NvsValue type);
bool VerifyNvsValueVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
struct I32Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef I32ValueBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUE = 4
};
int32_t value() const {
return GetField<int32_t>(VT_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_VALUE, 4) &&
verifier.EndTable();
}
};
struct I32ValueBuilder {
typedef I32Value Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_value(int32_t value) {
fbb_.AddElement<int32_t>(I32Value::VT_VALUE, value, 0);
}
explicit I32ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<I32Value> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<I32Value>(end);
return o;
}
};
inline ::flatbuffers::Offset<I32Value> CreateI32Value(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t value = 0) {
I32ValueBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}
struct U32Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef U32ValueBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUE = 4
};
uint32_t value() const {
return GetField<uint32_t>(VT_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_VALUE, 4) &&
verifier.EndTable();
}
};
struct U32ValueBuilder {
typedef U32Value Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_value(uint32_t value) {
fbb_.AddElement<uint32_t>(U32Value::VT_VALUE, value, 0);
}
explicit U32ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<U32Value> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<U32Value>(end);
return o;
}
};
inline ::flatbuffers::Offset<U32Value> CreateU32Value(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t value = 0) {
U32ValueBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}
struct I64Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef I64ValueBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUE = 4
};
int64_t value() const {
return GetField<int64_t>(VT_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
verifier.EndTable();
}
};
struct I64ValueBuilder {
typedef I64Value Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_value(int64_t value) {
fbb_.AddElement<int64_t>(I64Value::VT_VALUE, value, 0);
}
explicit I64ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<I64Value> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<I64Value>(end);
return o;
}
};
inline ::flatbuffers::Offset<I64Value> CreateI64Value(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t value = 0) {
I64ValueBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}
struct U64Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef U64ValueBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUE = 4
};
uint64_t value() const {
return GetField<uint64_t>(VT_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_VALUE, 8) &&
verifier.EndTable();
}
};
struct U64ValueBuilder {
typedef U64Value Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_value(uint64_t value) {
fbb_.AddElement<uint64_t>(U64Value::VT_VALUE, value, 0);
}
explicit U64ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<U64Value> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<U64Value>(end);
return o;
}
};
inline ::flatbuffers::Offset<U64Value> CreateU64Value(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t value = 0) {
U64ValueBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}
struct StringValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef StringValueBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUE = 4
};
const ::flatbuffers::String *value() const {
return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VALUE) &&
verifier.VerifyString(value()) &&
verifier.EndTable();
}
};
struct StringValueBuilder {
typedef StringValue Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
fbb_.AddOffset(StringValue::VT_VALUE, value);
}
explicit StringValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<StringValue> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<StringValue>(end);
return o;
}
};
inline ::flatbuffers::Offset<StringValue> CreateStringValue(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> value = 0) {
StringValueBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}
inline ::flatbuffers::Offset<StringValue> CreateStringValueDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *value = nullptr) {
auto value__ = value ? _fbb.CreateString(value) : 0;
return Messaging::CreateStringValue(
_fbb,
value__);
}
struct BlobValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BlobValueBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VALUE = 4
};
const ::flatbuffers::Vector<uint8_t> *value() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_VALUE);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VALUE) &&
verifier.VerifyVector(value()) &&
verifier.EndTable();
}
};
struct BlobValueBuilder {
typedef BlobValue Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_value(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> value) {
fbb_.AddOffset(BlobValue::VT_VALUE, value);
}
explicit BlobValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BlobValue> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BlobValue>(end);
return o;
}
};
inline ::flatbuffers::Offset<BlobValue> CreateBlobValue(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> value = 0) {
BlobValueBuilder builder_(_fbb);
builder_.add_value(value);
return builder_.Finish();
}
inline ::flatbuffers::Offset<BlobValue> CreateBlobValueDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *value = nullptr) {
auto value__ = value ? _fbb.CreateVector<uint8_t>(*value) : 0;
return Messaging::CreateBlobValue(
_fbb,
value__);
}
struct ConfigMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ConfigMessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_KEY = 4,
VT_TYPE = 6,
VT_VALUE_TYPE = 8,
VT_VALUE = 10
};
const ::flatbuffers::String *key() const {
return GetPointer<const ::flatbuffers::String *>(VT_KEY);
}
Messaging::EntryType type() const {
return static_cast<Messaging::EntryType>(GetField<int8_t>(VT_TYPE, 0));
}
Messaging::NvsValue value_type() const {
return static_cast<Messaging::NvsValue>(GetField<uint8_t>(VT_VALUE_TYPE, 0));
}
const void *value() const {
return GetPointer<const void *>(VT_VALUE);
}
template<typename T> const T *value_as() const;
const Messaging::I32Value *value_as_I32Value() const {
return value_type() == Messaging::NvsValue_I32Value ? static_cast<const Messaging::I32Value *>(value()) : nullptr;
}
const Messaging::U32Value *value_as_U32Value() const {
return value_type() == Messaging::NvsValue_U32Value ? static_cast<const Messaging::U32Value *>(value()) : nullptr;
}
const Messaging::I64Value *value_as_I64Value() const {
return value_type() == Messaging::NvsValue_I64Value ? static_cast<const Messaging::I64Value *>(value()) : nullptr;
}
const Messaging::U64Value *value_as_U64Value() const {
return value_type() == Messaging::NvsValue_U64Value ? static_cast<const Messaging::U64Value *>(value()) : nullptr;
}
const Messaging::StringValue *value_as_StringValue() const {
return value_type() == Messaging::NvsValue_StringValue ? static_cast<const Messaging::StringValue *>(value()) : nullptr;
}
const Messaging::BlobValue *value_as_BlobValue() const {
return value_type() == Messaging::NvsValue_BlobValue ? static_cast<const Messaging::BlobValue *>(value()) : nullptr;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_KEY) &&
verifier.VerifyString(key()) &&
VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
VerifyField<uint8_t>(verifier, VT_VALUE_TYPE, 1) &&
VerifyOffset(verifier, VT_VALUE) &&
VerifyNvsValue(verifier, value(), value_type()) &&
verifier.EndTable();
}
};
template<> inline const Messaging::I32Value *ConfigMessage::value_as<Messaging::I32Value>() const {
return value_as_I32Value();
}
template<> inline const Messaging::U32Value *ConfigMessage::value_as<Messaging::U32Value>() const {
return value_as_U32Value();
}
template<> inline const Messaging::I64Value *ConfigMessage::value_as<Messaging::I64Value>() const {
return value_as_I64Value();
}
template<> inline const Messaging::U64Value *ConfigMessage::value_as<Messaging::U64Value>() const {
return value_as_U64Value();
}
template<> inline const Messaging::StringValue *ConfigMessage::value_as<Messaging::StringValue>() const {
return value_as_StringValue();
}
template<> inline const Messaging::BlobValue *ConfigMessage::value_as<Messaging::BlobValue>() const {
return value_as_BlobValue();
}
struct ConfigMessageBuilder {
typedef ConfigMessage Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
fbb_.AddOffset(ConfigMessage::VT_KEY, key);
}
void add_type(Messaging::EntryType type) {
fbb_.AddElement<int8_t>(ConfigMessage::VT_TYPE, static_cast<int8_t>(type), 0);
}
void add_value_type(Messaging::NvsValue value_type) {
fbb_.AddElement<uint8_t>(ConfigMessage::VT_VALUE_TYPE, static_cast<uint8_t>(value_type), 0);
}
void add_value(::flatbuffers::Offset<void> value) {
fbb_.AddOffset(ConfigMessage::VT_VALUE, value);
}
explicit ConfigMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ConfigMessage> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ConfigMessage>(end);
return o;
}
};
inline ::flatbuffers::Offset<ConfigMessage> CreateConfigMessage(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> key = 0,
Messaging::EntryType type = Messaging::EntryType_NONE,
Messaging::NvsValue value_type = Messaging::NvsValue_NONE,
::flatbuffers::Offset<void> value = 0) {
ConfigMessageBuilder builder_(_fbb);
builder_.add_value(value);
builder_.add_key(key);
builder_.add_value_type(value_type);
builder_.add_type(type);
return builder_.Finish();
}
inline ::flatbuffers::Offset<ConfigMessage> CreateConfigMessageDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *key = nullptr,
Messaging::EntryType type = Messaging::EntryType_NONE,
Messaging::NvsValue value_type = Messaging::NvsValue_NONE,
::flatbuffers::Offset<void> value = 0) {
auto key__ = key ? _fbb.CreateString(key) : 0;
return Messaging::CreateConfigMessage(
_fbb,
key__,
type,
value_type,
value);
}
inline bool VerifyNvsValue(::flatbuffers::Verifier &verifier, const void *obj, NvsValue type) {
switch (type) {
case NvsValue_NONE: {
return true;
}
case NvsValue_I32Value: {
auto ptr = reinterpret_cast<const Messaging::I32Value *>(obj);
return verifier.VerifyTable(ptr);
}
case NvsValue_U32Value: {
auto ptr = reinterpret_cast<const Messaging::U32Value *>(obj);
return verifier.VerifyTable(ptr);
}
case NvsValue_I64Value: {
auto ptr = reinterpret_cast<const Messaging::I64Value *>(obj);
return verifier.VerifyTable(ptr);
}
case NvsValue_U64Value: {
auto ptr = reinterpret_cast<const Messaging::U64Value *>(obj);
return verifier.VerifyTable(ptr);
}
case NvsValue_StringValue: {
auto ptr = reinterpret_cast<const Messaging::StringValue *>(obj);
return verifier.VerifyTable(ptr);
}
case NvsValue_BlobValue: {
auto ptr = reinterpret_cast<const Messaging::BlobValue *>(obj);
return verifier.VerifyTable(ptr);
}
default: return true;
}
}
inline bool VerifyNvsValueVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
if (!VerifyNvsValue(
verifier, values->Get(i), types->GetEnum<NvsValue>(i))) {
return false;
}
}
return true;
}
inline const Messaging::ConfigMessage *GetConfigMessage(const void *buf) {
return ::flatbuffers::GetRoot<Messaging::ConfigMessage>(buf);
}
inline const Messaging::ConfigMessage *GetSizePrefixedConfigMessage(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<Messaging::ConfigMessage>(buf);
}
inline bool VerifyConfigMessageBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Messaging::ConfigMessage>(nullptr);
}
inline bool VerifySizePrefixedConfigMessageBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::ConfigMessage>(nullptr);
}
inline void FinishConfigMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::ConfigMessage> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedConfigMessageBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::ConfigMessage> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Messaging
#endif // FLATBUFFERS_GENERATED_CONFIGMESSAGE_MESSAGING_H_

5
components/rpc/CommunicationRouter.cpp
View File

@@ -5,6 +5,7 @@
#include "freertos/queue.h"
CommunicationRouter::~CommunicationRouter() {
vTaskDelete(m_router_thread);
vQueueDelete(m_tcp_rx_queue);
}
@@ -19,3 +20,7 @@ CommunicationRouter::~CommunicationRouter() {
std::cout << "callback" << std::endl;
}
}
int CommunicationRouter::send_msg(char* buffer, const size_t length) const {
return this->m_tcp_server->send_msg(buffer, length);
}

12
components/rpc/MessagingInterface.cpp
View File

@@ -4,21 +4,31 @@
#include "MessagingInterface.h"
#include <ConfigManager.h>
#include <freertos/queue.h>
#include <freertos/semphr.h>
#include "MPIMessageBuilder.h"
MessagingInterface::~MessagingInterface() {
vQueueDelete(m_mpi_rx_queue);
vSemaphoreDelete(m_map_semaphore);
for (const auto [_tag, queue] : m_tag_to_queue) {
vQueueDelete(queue);
}
}
int MessagingInterface::send(char* buffer, int size, int destination, int tag, bool durable) {
Flatbuffers::MPIMessageBuilder builder;
const auto [mpi_buffer, mpi_size] = builder.build_mpi_message(Messaging::MessageType_PTP, ConfigManager::get_module_id(), destination, sequence_number++, durable, tag, std::vector<uint8_t>(buffer, buffer + size));
m_router->send_msg(static_cast<char *>(mpi_buffer), mpi_size);
return 0;
}
int MessagingInterface::broadcast(char* buffer, int size, int root, bool durable) {
// todo: impl
return 0;
}

22
components/rpc/TCPServer.cpp
View File

@@ -9,6 +9,7 @@
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include <lwip/netdb.h>
#include <iostream>
#include "TCPServer.h"
@@ -20,13 +21,12 @@
// - authenticate (don't just return true from the auth function)
// - tx from board
TCPServer::TCPServer(const int port, QueueHandle_t rx_queue) {
TCPServer::TCPServer(const int port, const QueueHandle_t rx_queue) {
this->m_port = port;
this->m_mutex = xSemaphoreCreateMutex();
this->m_clients = std::unordered_set<int>();
this->m_task = nullptr;
this->m_rx_task = nullptr;
this->m_tx_task = nullptr;
this->m_rx_queue = rx_queue;
this->m_server_sock = 0;
@@ -37,7 +37,6 @@ TCPServer::TCPServer(const int port, QueueHandle_t rx_queue) {
TCPServer::~TCPServer() {
vTaskDelete(this->m_task);
vTaskDelete(this->m_rx_task);
vTaskDelete(this->m_tx_task);
vSemaphoreDelete(this->m_mutex);
}
@@ -149,6 +148,7 @@ TCPServer::~TCPServer() {
if (len < 0) {
printf("Error occurred during receiving: errno %d\n", errno);
to_remove.emplace_back(sock);
} else if (0 == len) {
printf("Connection closed\n");
close(sock);
@@ -198,3 +198,19 @@ bool TCPServer::authenticate_client(int sock) {
// todo: authentication (wait for a passphrase from the client)
return 0;
}
int TCPServer::send_msg(char *buffer, size_t length) const {
// todo: should we assign a unique rank to each pc?
if (!is_network_connected()) {
return -1;
}
for (const auto client_sock : m_clients) {
std::cout << "sending tcp" << std::endl;
send(client_sock, buffer, length, 0);
}
return 0;
}

2
components/rpc/include/CommunicationRouter.h
View File

@@ -28,6 +28,8 @@ public:
[[noreturn]] static void router_thread(void *args);
int send_msg(char* buffer, size_t length) const;
// todo: does this really need to be here (so i can access from thread)?
QueueHandle_t m_tcp_rx_queue;
std::function<void(char*, int)> m_rx_callback;

2
components/rpc/include/TCPServer.h
View File

@@ -16,6 +16,7 @@ class TCPServer : IRPCServer {
public:
TCPServer(int port, QueueHandle_t rx_queue);
~TCPServer();
int send_msg(char* buffer, size_t length) const;
private:
bool authenticate_client(int client_sock);
@@ -29,7 +30,6 @@ private:
TaskHandle_t m_task;
TaskHandle_t m_rx_task;
TaskHandle_t m_tx_task;
QueueHandle_t m_rx_queue;