alexander/gobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Renamed Files and added Heart beat

Browse Source
This commit is contained in:
AlexanderHD27
2024-12-30 17:17:07 +01:00
parent 58043ee0d5
commit edc2dd6294
14 changed files with 188 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
i2c-hub/backend/Protocol.md (Stored with Git LFS)
View File

Binary file not shown.

29
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_base.cpp
View File

@@ -1,17 +1,40 @@
#include "uart_ctrl.hpp"
#include "ctrl_interface.hpp"
#include <stdint.h>
#include <stdio.h>
#include <stdarg.h>
GobotRPC_CtrlInterface::GobotRPC_CtrlInterface(GobotRPC_CtrlInterface_HardwareHandler *handler) {
this->handler = handler;
GobotRPC_CtrlInterface::GobotRPC_CtrlInterface(I_GobotRPC_CtrlInterface_HardwareHandler *ctrlInterface) {
this->handler = ctrlInterface;
handler->registerCallback(externalCallback_RX, this);
handler->registerHeartBeatCallback(externalCallback_HeartBeat, this);
packetCallback = nullptr;
performScanCallback = nullptr;
getInfoCallback = nullptr;
reqSlotUpdateCallback = nullptr;
packetCallbackArgs = nullptr;
performScanCallbackArgs = nullptr;
getInfoCallbackArgs = nullptr;
reqSlotUpdateCallbackArgs = nullptr;
}
void GobotRPC_CtrlInterface::printf(const char *fmt, ...) {
char buffer[256];
va_list args;
va_start(args, fmt);
vsnprintf(buffer, 256, fmt, args);
handler->send(buffer, strlen(buffer));
}
// Sending HeartBeat
void GobotRPC_CtrlInterface::onHeartBeat() {
char buffer = GOBOTRPC_CTRL_CMD_HEART_BEAT;
handler->send(&buffer, 1);
}
void externalCallback_HeartBeat(void * args) {
GobotRPC_CtrlInterface *ctrlInterface = (GobotRPC_CtrlInterface *)args;
ctrlInterface->onHeartBeat();
}

36
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_hardware_rp2040.cpp
View File

@@ -1,4 +1,4 @@
#include "uart_ctrl_hardware.hpp"
#include "ctrl_interface.hpp"
#ifdef GOBOTRPC_PLATFORM_RP2040
#include "pico/stdlib.h"
@@ -15,12 +15,20 @@
GobotRPC_CtrlInterface_HardwareHandler_RP2040 * g_uart_hardware_handler;
GobotRPC_CtrlInterface_HardwareHandler_RP2040::GobotRPC_CtrlInterface_HardwareHandler_RP2040(
uart_inst_t * uart_instance, uint baudrate,
uart_inst_t * uart_instance, uint baudrate, uint heartBeatDelay,
uint tx_pin, uint rx_pin) {
callback_rx = nullptr;
callback_args = nullptr;
callback_heart_beat = nullptr;
callback_heart_beat_args = nullptr;
this->heartBeatDelay = heartBeatDelay;
this->rxSemphrHandle = xSemaphoreCreateCounting(16, 0);
g_uart_hardware_handler = this;
xTaskCreate(vTaskRxHandler, "gobotrpc_ctrl_interface_uart_rx", 512, this, 3, &this->rxTaskHandle);
xTaskCreate(vTaskRxHandler, "gobotrpc_ctrl_interface_uart_rx", 1024, this, 3, &this->rxTaskHandle);
xTaskCreate(vTaskHeartBeat, "gobotrpc_ctrl_interface_heart_beat", 1024, this, 2, &this->heartBeatTaskHandle);
gpio_set_function(tx_pin, UART_FUNCSEL_NUM(uart_instance, tx_pin));
gpio_set_function(rx_pin, UART_FUNCSEL_NUM(uart_instance, rx_pin));
@@ -38,13 +46,12 @@ GobotRPC_CtrlInterface_HardwareHandler_RP2040::GobotRPC_CtrlInterface_HardwareHa
uart_set_fifo_enabled(uart_instance, true);
}
// TODO: Implement this!
void GobotRPC_CtrlInterface_HardwareHandler_RP2040::send(char * data, size_t length) {
uart_write_blocking(uart_instance, (const uint8_t *)data, length);
uart_tx_wait_blocking(uart_instance);
}
void GobotRPC_CtrlInterface_HardwareHandler_RP2040::registerCallback(UART_CTRL_Callback_RX callback, void * args) {
void GobotRPC_CtrlInterface_HardwareHandler_RP2040::registerCallback(GobotRPC_CtrlInterface_Callback_RX callback, void * args) {
this->callback_rx = callback;
this->callback_args = args;
}
@@ -66,6 +73,21 @@ void GobotRPC_CtrlInterface_HardwareHandler_RP2040::rxTaskHandler() {
}
}
void GobotRPC_CtrlInterface_HardwareHandler_RP2040::heartBeatTaskHandler() {
while (true) {
if (this->callback_heart_beat != nullptr) {
this->callback_heart_beat(this->callback_heart_beat_args);
}
vTaskDelay(this->heartBeatDelay / portTICK_PERIOD_MS);
}
}
void GobotRPC_CtrlInterface_HardwareHandler_RP2040::registerHeartBeatCallback(GobotRPC_CtrlInterface_Callback_HeartBeat callback, void * args) {
this->callback_heart_beat = callback;
this->callback_heart_beat_args = args;
}
void GobotRPC_CtrlInterface_HardwareHandler_RP2040::scheduleRXHandler(BaseType_t * higher_priority_task_woken) {
irq_clear(this->UART_IRQ);
if (this->callback_rx != nullptr) {
@@ -77,6 +99,10 @@ void vTaskRxHandler(void * pvParameters) {
g_uart_hardware_handler->rxTaskHandler();
}
void vTaskHeartBeat(void * pvParameters) {
g_uart_hardware_handler->heartBeatTaskHandler();
}
void isrUartRX() {
static BaseType_t higher_priority_task_woken = pdFALSE;
g_uart_hardware_handler->scheduleRXHandler(&higher_priority_task_woken);

2
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_registers.cpp
View File

@@ -1,4 +1,4 @@
#include "uart_ctrl.hpp"
#include "ctrl_interface.hpp"
#include <string.h>
void GobotRPC_CtrlInterface::registerCallback_Packet(GobotRPC_CtrlInterface_Callback_Packet callback, void *args) {

2
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_rx.cpp
View File

@@ -1,4 +1,4 @@
#include "uart_ctrl.hpp"
#include "ctrl_interface.hpp"
#include "gobotrpc.hpp"
#include <string.h>

2
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_tx.cpp
View File

@@ -1,4 +1,4 @@
#include "uart_ctrl.hpp"
#include "ctrl_interface.hpp"
#include <string.h>
// This function should be called when a package is sent

13
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/uart_ctrl.hpp → i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/ctrl_interface.hpp
View File

@@ -1,7 +1,7 @@
#pragma once
#include <stdint.h>
#include "gobotrpc.hpp"
#include "uart_ctrl_hardware.hpp"
#include "gobotrpc_datatypes.hpp"
#include "ctrl_interface_hardware.hpp"
struct HubInfo {
uint8_t slotNumbers;
@@ -13,6 +13,7 @@ typedef void (*GobotRPC_CtrlInterface_Callback_ReqSlotUpdate)(void * args, bool
typedef HubInfo (*GobotRPC_CtrlInterface_Callback_GetInfo)(void * args);
void externalCallback_RX(void * args, char * data, size_t length);
void externalCallback_HeartBeat(void * args);
class GobotRPC_CtrlInterface {
private:
@@ -25,7 +26,7 @@ private:
void * reqSlotUpdateCallbackArgs;
void * getInfoCallbackArgs;
GobotRPC_CtrlInterface_HardwareHandler * handler;
I_GobotRPC_CtrlInterface_HardwareHandler * handler;
protected:
void onRX_Packet(char * data, size_t length);
void onRX_PerformScan(char * data, size_t length);
@@ -33,8 +34,11 @@ protected:
void onRX_GetInfo(char * data, size_t length);
public:
GobotRPC_CtrlInterface(GobotRPC_CtrlInterface_HardwareHandler * handler);
GobotRPC_CtrlInterface(I_GobotRPC_CtrlInterface_HardwareHandler * handler);
void printf(const char *fmt, ...);
void onRX(char * data, size_t length);
void onHeartBeat();
void pushPacket(RPCPackage package);
void pushScanResulst(uint32_t addr, bool running);
@@ -54,5 +58,6 @@ enum UART_CTRL_Command_ID {
GOBOTRPC_CTRL_CMD_SCAN_RESULT = 0x83, // Hub -> Host
GOBOTRPC_CTRL_CMD_SLOT_UPDATE = 0x84, // Hub -> Host
GOBOTRPC_CTRL_CMD_REQ_SLOT_UPDATE = 0x85, // Host -> Hub
GOBOTRPC_CTRL_CMD_HEART_BEAT = 0xfe, // Host <- Hub
GOBOTRPC_CTRL_CMD_INFO = 0xff, // Host -> Hub, Hub -> Host
};

58
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/ctrl_interface_hardware.hpp Normal file
View File

@@ -0,0 +1,58 @@
#pragma once
#include <string.h>
typedef void (*GobotRPC_CtrlInterface_Callback_RX)(void * args, char * data, size_t length);
typedef void (*GobotRPC_CtrlInterface_Callback_HeartBeat)(void * args);
class I_GobotRPC_CtrlInterface_HardwareHandler {
public:
virtual void send(char * data, size_t length) = 0;
virtual void registerCallback(GobotRPC_CtrlInterface_Callback_RX, void * args) = 0;
virtual void registerHeartBeatCallback(GobotRPC_CtrlInterface_Callback_HeartBeat, void * args) = 0;
};
#define GOBOTRPC_PLATFORM_RP2040
#ifdef GOBOTRPC_PLATFORM_RP2040
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "hardware/uart.h"
class GobotRPC_CtrlInterface_HardwareHandler_RP2040 : public I_GobotRPC_CtrlInterface_HardwareHandler {
private:
uart_inst_t * uart_instance;
int UART_IRQ;
GobotRPC_CtrlInterface_Callback_RX callback_rx;
void * callback_args;
GobotRPC_CtrlInterface_Callback_HeartBeat callback_heart_beat;
void * callback_heart_beat_args;
xSemaphoreHandle rxSemphrHandle;
TaskHandle_t rxTaskHandle;
TaskHandle_t heartBeatTaskHandle;
uint heartBeatDelay;
public:
GobotRPC_CtrlInterface_HardwareHandler_RP2040(uart_inst_t * uart_instance, uint baudrate, uint heartBeatDelay, uint tx_pin, uint rx_pin);
void send(char * data, size_t length) override;
void registerCallback(GobotRPC_CtrlInterface_Callback_RX, void * args) override;
void registerHeartBeatCallback(GobotRPC_CtrlInterface_Callback_HeartBeat, void * args);
void rxTaskHandler();
void heartBeatTaskHandler();
void scheduleRXHandler(BaseType_t * higher_priority_task_woken);
};
extern GobotRPC_CtrlInterface_HardwareHandler_RP2040 * g_uart_hardware_handler;
void isrUartRX();
void vTaskRxHandler(void * pvParameters);
void vTaskHeartBeat(void * pvParameters);
#endif

43
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/gobotrpc.hpp
View File

@@ -2,42 +2,11 @@
#include <stdint.h>
#include <strings.h>
#include "protocol.hpp"
#define MAX_PAGE_SIZES 4*7
enum FrameSubmitionResult {
PENDING,
COMPLEATE,
ERROR_INVALID_RPC_TYPE,
ERROR_INVALID_RPC_NUMBER,
ERROR_NO_EMPTY_OR_FITTING_SLOT,
};
struct RPC_RX_PackageSlot {
char buffer[MAX_PAGE_SIZES];
bool is_complete;
bool is_in_use;
uint32_t sender_address;
enum RPCNumber rpcNum;
enum RPCType type;
uint32_t used_bit_masked;
uint32_t timestamp;
size_t length;
};
struct RPCPackage {
char buffer[MAX_PAGE_SIZES];
size_t length;
uint32_t addr;
RPCNumber rpcNum;
RPCType type;
};
#define NUM_SLOTS 8
#include "gobotrpc_datatypes.hpp"
#include "ctrl_interface.hpp"
#include "ctrl_interface_hardware.hpp"
class GobotRPC_CtrlInterface;
class GobotRPCParser {
private:
RPC_RX_PackageSlot buffer[NUM_SLOTS];
@@ -46,12 +15,14 @@ private:
size_t finishedScanIndex;
GobotRPC_CtrlInterface * ctrlInterface;
void find_fitting_slot(RPCHeader header, uint32_t addr, int * fitting_slot, int * empty_slot);
static void insertFrameInPackageSlot(RPC_RX_PackageSlot * package, char * data, size_t segment, size_t length);
void freePackageSlot(size_t index);
public:
GobotRPCParser();
GobotRPCParser(GobotRPC_CtrlInterface * ctrlInterface);
void print_out_slots();
enum FrameSubmitionResult submit_frame(char * data, size_t length, uint32_t addr, uint32_t timestamp);

35
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/gobotrpc_datatypes.hpp Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include "protocol.hpp"
#define MAX_PAGE_SIZES 4*7
#define NUM_SLOTS 8
enum FrameSubmitionResult {
PENDING,
COMPLEATE,
ERROR_INVALID_RPC_TYPE,
ERROR_INVALID_RPC_NUMBER,
ERROR_NO_EMPTY_OR_FITTING_SLOT,
};
struct RPC_RX_PackageSlot {
char buffer[MAX_PAGE_SIZES];
bool is_complete;
bool is_in_use;
uint32_t sender_address;
enum RPCNumber rpcNum;
enum RPCType type;
uint32_t used_bit_masked;
uint32_t timestamp;
size_t length;
};
struct RPCPackage {
char buffer[MAX_PAGE_SIZES];
size_t length;
uint32_t addr;
RPCNumber rpcNum;
RPCType type;
};

45
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/uart_ctrl_hardware.hpp
View File

@@ -1,45 +0,0 @@
#pragma once
#include <string.h>
typedef void (*UART_CTRL_Callback_RX)(void * args, char * data, size_t length);
class GobotRPC_CtrlInterface_HardwareHandler {
public:
virtual void send(char * data, size_t length) = 0;
virtual void registerCallback(UART_CTRL_Callback_RX, void * args) = 0;
};
#define GOBOTRPC_PLATFORM_RP2040
#ifdef GOBOTRPC_PLATFORM_RP2040
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "hardware/uart.h"
class GobotRPC_CtrlInterface_HardwareHandler_RP2040 : public GobotRPC_CtrlInterface_HardwareHandler {
private:
uart_inst_t * uart_instance;
int UART_IRQ;
UART_CTRL_Callback_RX callback_rx;
void * callback_args;
xSemaphoreHandle rxSemphrHandle;
TaskHandle_t rxTaskHandle;
public:
GobotRPC_CtrlInterface_HardwareHandler_RP2040(uart_inst_t * uart_instance, uint baudrate, uint tx_pin, uint rx_pin);
void send(char * data, size_t length) override;
void registerCallback(UART_CTRL_Callback_RX, void * args) override;
void rxTaskHandler();
void scheduleRXHandler(BaseType_t * higher_priority_task_woken);
};
extern GobotRPC_CtrlInterface_HardwareHandler_RP2040 * g_uart_hardware_handler;
void isrUartRX();
void vTaskRxHandler(void * pvParameters);
#endif

4
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/init.cpp
View File

@@ -1,7 +1,9 @@
#include "gobotrpc.hpp"
#include <string.h>
GobotRPCParser::GobotRPCParser() {
GobotRPCParser::GobotRPCParser(GobotRPC_CtrlInterface * ctrlInterface) {
this->ctrlInterface = ctrlInterface;
for(int i = 0; i < NUM_SLOTS; i++) {
buffer[i].timestamp = 0;
buffer[i].is_complete = false;

5
i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/rx.cpp
View File

@@ -2,8 +2,6 @@
#include "protocol.hpp"
#include <string.h>
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
RPCHeader parseRPCHeader(char data)
{
RPCHeader header;
@@ -54,6 +52,9 @@ FrameSubmitionResult GobotRPCParser::submit_frame(char *data, size_t length, uin
this->buffer[slotNum].timestamp = timestamp;
this->buffer[slotNum].length = MAX(this->buffer[slotNum].length, header.segment*7 + (length - 1));
volatile FrameSubmitionResult res = getPackageStatus(&(this->buffer[slotNum]));
// Push the update to the control interface
ctrlInterface->pushPackageSlotUpdate(res == COMPLEATE, this->buffer[slotNum].is_in_use, slotNum, addr, timestamp, this->buffer[slotNum].used_bit_masked);
if (res == COMPLEATE) {
this->buffer[slotNum].is_complete = true;

46
i2c-hub/firmware/i2c-hub-firmware/src/main.cpp
View File

@@ -9,55 +9,34 @@
#include "gobotrpc/include/gobotrpc.hpp"
#include "uart_ctrl_hardware.hpp"
#include "ctrl_interface_hardware.hpp"
void TaskFn(void * args) {
printf("\n\n\n\n");
printf("%d\n", xPortGetFreeHeapSize());
void vTaskMain(void * args) {
GobotRPC_CtrlInterface_HardwareHandler_RP2040 uartHandler(uart0, 115200, 500, 0, 1);
GobotRPC_CtrlInterface ctrlInterface(&uartHandler);
GobotRPCParser rpcRXParser(&ctrlInterface);
GobotRPC_CtrlInterface_HardwareHandler_RP2040 uartHandler(uart0, 115200, 0, 1);
GobotRPCParser rpcRXParser;
ctrlInterface.printf("Hello World!\n");
char data0[] = "\x04\x01\x02\x03\x04\x05\x06";
char data1[] = "\x44\x11\x12\x13\x14\x15\x16";
char data3[] = "\x11\xaa\xbb\xcc\xdd\xee\xff";
char data2[] = "\x84\xaa\xbb";
rpcRXParser.submit_frame(data2, 3, 0x42, xTaskGetTickCount());
rpcRXParser.print_out_slots();
printf("\n");
rpcRXParser.submit_frame(data3, 7, 0x43, xTaskGetTickCount());
rpcRXParser.print_out_slots();
printf("\n");
rpcRXParser.submit_frame(data1, 7, 0x42, xTaskGetTickCount());
rpcRXParser.print_out_slots();
printf("\n");
vTaskDelay(10 / portTICK_PERIOD_MS);
rpcRXParser.submit_frame(data3, 7, 0x43, xTaskGetTickCount());
rpcRXParser.print_out_slots();
printf("\n");
rpcRXParser.submit_frame(data0, 7, 0x42, xTaskGetTickCount());
rpcRXParser.print_out_slots();
printf("\n");
size_t index = rpcRXParser.getFinishedIndexPackages();
printf("Index: %d\n", index);
RPCPackage package;
rpcRXParser.retrivePackage(&package, index);
for(int i=0; i<MAX_PAGE_SIZES; i++) {
printf("%02x", package.buffer[i]);
}
printf("\n");
rpcRXParser.print_out_slots();
while (true) {
gpio_put(LED_PIN, false);
vTaskDelay(500 / portTICK_PERIOD_MS);
@@ -67,20 +46,17 @@ void TaskFn(void * args) {
}
int main() {
stdio_init_all();
printf("============================================\n");
printf(" Gobot RPC Hub \n");
printf("============================================\n");
gpio_init(LED_PIN);
gpio_set_dir(LED_PIN, true);
printf("HelloWorld!\n");
TaskHandle_t taskHandle;
xTaskCreate(TaskFn, "UART Task", 1024, NULL, 1, &taskHandle);
xTaskCreate(vTaskMain, "Main Task", 2048, NULL, 1, &taskHandle);
vTaskStartScheduler();
while(1) {}