Renamed Files and added Heart beat

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_base.cpp

@@ -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) {
+GobotRPC_CtrlInterface::GobotRPC_CtrlInterface(I_GobotRPC_CtrlInterface_HardwareHandler *ctrlInterface) {
-    this->handler = handler;
+    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();
+}

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_hardware_rp2040.cpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_registers.cpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_rx.cpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/ctrl_interface/ctrl_interface_tx.cpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/ctrl_interface.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include <stdint.h>
-#include "gobotrpc.hpp"
+#include "gobotrpc_datatypes.hpp"
-#include "uart_ctrl_hardware.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
 };

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/ctrl_interface_hardware.hpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/gobotrpc.hpp

@@ -2,42 +2,11 @@
 #include <stdint.h>
 #include <strings.h>
 
-#include "protocol.hpp"
+#include "gobotrpc_datatypes.hpp"
-
+#include "ctrl_interface.hpp"
-#define MAX_PAGE_SIZES 4*7
+#include "ctrl_interface_hardware.hpp"
-
-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
 
+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);

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/gobotrpc_datatypes.hpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/include/uart_ctrl_hardware.hpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/init.cpp

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

i2c-hub/firmware/i2c-hub-firmware/src/gobotrpc/rx.cpp

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

i2c-hub/firmware/i2c-hub-firmware/src/main.cpp

@@ -9,55 +9,34 @@
 
 
 #include "gobotrpc/include/gobotrpc.hpp"
-#include "uart_ctrl_hardware.hpp"
+#include "ctrl_interface_hardware.hpp"
 
-void TaskFn(void * args) {
+void vTaskMain(void * args) {
-  printf("\n\n\n\n");
+    GobotRPC_CtrlInterface_HardwareHandler_RP2040 uartHandler(uart0, 115200, 500, 0, 1);
-    printf("%d\n", xPortGetFreeHeapSize());
+    GobotRPC_CtrlInterface ctrlInterface(&uartHandler);
+    GobotRPCParser rpcRXParser(&ctrlInterface);
 
-    GobotRPC_CtrlInterface_HardwareHandler_RP2040 uartHandler(uart0, 115200, 0, 1);
+    ctrlInterface.printf("Hello World!\n");
-
-    GobotRPCParser rpcRXParser;
 
     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) {}