added handling of CanData To Tasks

Application/Tasks/CMakeLists.txt

@@ -7,9 +7,14 @@ add_library(${PROJECT_NAME} STATIC "")
 target_sources(${PROJECT_NAME} 
     PRIVATE
     ${CMAKE_CURRENT_LIST_DIR}/UsbDataHandler.c
+    ${CMAKE_CURRENT_LIST_DIR}/CanDataHandler.c
+    ${CMAKE_CURRENT_LIST_DIR}/CanDataTask.c
     ${CMAKE_CURRENT_LIST_DIR}/FirmwareHandler.c
     INTERFACE
     ${CMAKE_CURRENT_LIST_DIR}/UsbDataHandler.h
+    ${CMAKE_CURRENT_LIST_DIR}/CanDataHandler.h
+    ${CMAKE_CURRENT_LIST_DIR}/CanDataTask.h
+    
     )
 
 target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})

Application/Tasks/CanDataHandler.c

@@ -0,0 +1,299 @@
+#include "CanDataHandler.h"
+#include "fdcan.h"
+#include "string.h"
+
+#define MAX_DATA_STORAGE 100
+#define MAX_EVENT_STORAGE 100
+#define MAX_FILTER_SLOTS 100
+
+// storage for upto MAX_DATA_STORAGE diffrent messages
+static CanDataMessageSlot CanDataStore[MAX_DATA_STORAGE] = {0};
+
+// storage for upto MAX_EVENT_STORAGE diffrent event handlers
+static CanDataEventSlot CanEventStore[MAX_DATA_STORAGE] = {0};
+
+// storage for upto MAX_FILTER_SLOTS diffrent can filters
+static CanDataFilterSlot CanFilterSlots[MAX_FILTER_SLOTS] = {0};
+
+// this will setup the canfilter accoridng to the settings
+void setup_StmFdCanFilter(const CanDataFilterSlot* filterSetting ) {
+    size_t f_index =  filterSetting - CanFilterSlots;// index of the filter in CanFilterSlots
+
+    FDCAN_FilterTypeDef sFilterConfig;
+    sFilterConfig.IdType = FDCAN_STANDARD_ID;
+    sFilterConfig.FilterIndex = f_index;
+    sFilterConfig.FilterType = FDCAN_FILTER_DUAL;
+    sFilterConfig.FilterConfig = filterSetting->fifo;
+    sFilterConfig.FilterID1 = filterSetting->id[0];
+    sFilterConfig.FilterID2 = filterSetting->id[1];
+    HAL_FDCAN_ConfigFilter(&hfdcan1, &sFilterConfig);
+}
+
+
+void CanDataHandler_init(void) {
+    // Reset all data message slots
+    for (int i = 0; i < MAX_DATA_STORAGE; i++) {
+        CanDataStore[i].msg.canid = 0;
+        CanDataStore[i].msg.data_length = 0;
+        memset(CanDataStore[i].msg.data, 0, MAX_DATA_LENGTH);
+        CanDataStore[i].filter.ref = NULL;
+        CanDataStore[i].filter.index = 0;
+    }
+
+    // Reset all event message slots
+    for (int i = 0; i < MAX_EVENT_STORAGE; i++) {
+        CanEventStore[i].canid = 0;
+        CanEventStore[i].eventCall = NULL;
+        CanEventStore[i].filter.ref = NULL;
+        CanEventStore[i].filter.index = 0;
+    }
+
+    // Reset all filter slots
+    for (int i = 0; i < MAX_FILTER_SLOTS; i++) {
+        CanFilterSlots[i].free = CANDATA_ALLFREE;
+        CanFilterSlots[i].fifo = CANDATA_FIFOX_UNDEFIEND;
+        CanFilterSlots[i].id[0] = 0;
+        CanFilterSlots[i].id[1] = 0;
+    }
+}
+
+
+/**
+ * Finds and returns an unused filter slot. If no unused slot is found, returns NULL.
+ */
+CanDataFilterRef CanData_unusedFilterSlot(CanDataSlotFifo reqest_fifo) {
+    CanDataFilterRef filterRef = {NULL, 0};
+
+    for (size_t i = 0; i < MAX_FILTER_SLOTS; i++) {
+        // find a slot with free some id 
+        if (CanFilterSlots[i].free != CANDATA_FULL) {
+
+            // either the fifo settig matches or is undefined
+            if(CanFilterSlots[i].fifo == reqest_fifo  || CanFilterSlots[i].fifo == CANDATA_FIFOX_UNDEFIEND)
+            filterRef.ref = &CanFilterSlots[i];
+
+                // Determine the index based on the 'free' field
+                switch (CanFilterSlots[i].free) {
+                    case CANDATA_ALLFREE:
+                        filterRef.index = 0;
+                        CanFilterSlots[i].free = CANDATA_FREE1;
+                        break;
+                    case CANDATA_FREE1:
+                        filterRef.index = 1;
+                        CanFilterSlots[i].free = CANDATA_FULL;
+                        break;
+                    case CANDATA_FREE0:
+                        filterRef.index = 0;
+                        CanFilterSlots[i].free = CANDATA_FULL;
+                        break;
+                    default:
+                        break;
+                }
+
+            break;
+        } 
+    }
+    return filterRef;
+}
+
+void CanData_clearFilterSlot(CanDataFilterRef filter) {
+
+        // reset the filter can id
+        filter.ref->id[filter.index] = 0;
+
+        // set the slot as free
+        if(filter.index == 0) {
+            filter.ref->free = filter.ref->free & CANDATA_FREE0;
+        } else if( filter.index == 1) {
+            filter.ref->free = filter.ref->free & CANDATA_FREE1;
+        }
+
+        // if the filterslot is now fully free reset the fifo settings
+        if(filter.ref->free == CANDATA_ALLFREE) {
+            filter.ref->fifo = CANDATA_FIFOX_UNDEFIEND;
+        }
+
+        
+        // finaly write new HW config
+        setup_StmFdCanFilter(filter.ref);
+}
+
+/**
+ * Finds and returns an unused data message slot. If no unused slot is found, returns NULL.
+ */
+CanDataMessageSlot * CanData_unusedDataSlot() {
+    for (size_t i = 0; i < MAX_DATA_STORAGE; i++) {
+        if (CanDataStore[i].msg.canid == 0) {
+            return &CanDataStore[i];
+        }
+    }
+    return NULL; // No unused slot found
+}
+
+/**
+ * Finds and returns an unused event slot. If no unused slot is found, returns NULL.
+ */
+CanDataEventSlot * CanData_unusedEventSlot() {
+    for (size_t i = 0; i < MAX_EVENT_STORAGE; i++) {
+        if (CanEventStore[i].canid == 0) {
+            return &CanEventStore[i];
+        }
+    }
+    return NULL; // No unused slot found
+}
+
+/**
+ * Registers a data message with given CanDataId. Returns true if registration is successful, false otherwise.
+ */
+bool CanData_regDataMsg(CanDataId canid) {
+    
+    // check if we already have this canid to avoid duplicates
+    if(CanData_getDataMessage(canid) != NULL) {
+        return true; // but return true beause there is already a vaild entry for this canid
+    }
+
+    // Find an unused slot in the data store
+    CanDataMessageSlot *dataSlot = CanData_unusedDataSlot();
+    if (!dataSlot) {
+        return false; // No unused data slot available
+    }
+
+    // Find and configure an unused slot for the data message
+    CanDataFilterRef filter = CanData_unusedFilterSlot(CANDATA_FIFO0_DATA);
+    if (filter.ref == NULL) {
+        return false; // No unused filter slot available
+    }
+
+    // Configure the filter slot
+    filter.ref->id[filter.index] = canid;
+
+    // Set up the filter with the new settings
+    setup_StmFdCanFilter(filter.ref);
+
+
+    // Register the data message with the data slot
+    dataSlot->msg.canid = canid;
+    dataSlot->filter = filter; // Store the pointer to the filter slot
+
+    return true;
+}
+
+/**
+ * Registers a event message with given CanDataId. Returns true if registration is successful, false otherwise.
+ */
+bool CanData_regEventMsg(CanDataId canid, EventCallback event_callback) {
+
+    // Check for vaild callback
+    if(event_callback == NULL) {
+        return false;
+    }
+
+    // Check if the canid is already registered
+    for (int i = 0; i < MAX_EVENT_STORAGE; i++) {
+        if (CanEventStore[i].canid == canid) {
+            return false; // The canid is already registered
+        }
+    }
+
+    // Find an unused slot in the event store
+    CanDataEventSlot *eventSlot = CanData_unusedEventSlot();
+    if (eventSlot == NULL) {
+        return false; // No unused event slot available
+    }
+
+    // Find and configure an unused slot for the data message
+    CanDataFilterRef filter = CanData_unusedFilterSlot(CANDATA_FIFO0_DATA);
+    if (filter.ref == NULL) {
+        return false; // No unused filter slot available
+    }
+
+    // Configure the filter slot
+    filter.ref->id[filter.index] = canid;
+
+    // Set up the filter with the new settings
+    setup_StmFdCanFilter(filter.ref);
+
+    // Register the event message with the event slot
+    eventSlot->canid = canid;
+    eventSlot->eventCall = event_callback;
+    eventSlot->filter = filter; // Store the pointer to the filter slot
+
+    return true;
+}
+
+// Function to remove a CAN ID from Event Messages Register
+bool CanData_removeEvent(CanDataId canid) {
+    // Search for the event slot with the given CanDataId
+    for (size_t i = 0; i < MAX_EVENT_STORAGE; i++) {
+        if (CanEventStore[i].canid == canid) {
+            CanDataEventSlot * eventSlot = &CanEventStore[i];
+            CanDataFilterRef  filter = eventSlot->filter; 
+
+            // reset the CanDataEventSlot
+            eventSlot->canid =0;
+            eventSlot->eventCall = NULL;
+            eventSlot->filter.index =0;
+            eventSlot->filter.ref = NULL;
+
+
+            // reset the filter
+            CanData_clearFilterSlot(filter);
+
+            return true; 
+        }
+    }
+
+    return false;
+}
+
+
+
+
+// Function to insert a Data Message into the array
+void CanData_insertDataMessage(CanDataId canid, uint8_t* data, uint8_t data_length) {
+    if(data == NULL || data_length == 0 ) {
+        return;
+    }
+
+    // Search for the data slot with the given CanDataId
+    for (size_t i = 0; i < MAX_DATA_STORAGE; i++) {
+        if (CanDataStore[i].msg.canid == canid) {
+            // If found, update the data message in the slot
+            CanDataStore[i].msg.data_length = data_length;
+            memcpy(CanDataStore[i].msg.data, data, data_length);
+            return;
+        }
+    }
+}
+
+// Function to read stored Data Message based on CAN ID
+// Returns a const pointer to the stored data or NULL if not found
+const CanDataMessage* CanData_getDataMessage(CanDataId canid) {
+    // Search for the data message with the given CanDataId
+    for (size_t i = 0; i < MAX_DATA_STORAGE; i++) {
+        if (CanDataStore[i].msg.canid == canid) {
+            return &CanDataStore[i].msg; // Return a pointer to the found data message
+        }
+    }
+    return NULL; // No data message with the given CanDataId found
+}
+
+
+
+// Function to handle reception of Data Messages from FIFO0
+void CanData_canFifo0RxCallback(CanDataId canid, uint8_t* data, uint8_t len) {
+    // Insert the data message into the data store
+    CanData_insertDataMessage(canid, data, len);
+}
+
+// Function to handle reception of Event Messages from FIFO1
+void CanData_canFifo1RxCallback(CanDataId canid, uint8_t* data, uint8_t len) {
+    // Search for the event slot with the given CanDataId
+    for (size_t i = 0; i < MAX_EVENT_STORAGE; i++) {
+        if (CanEventStore[i].canid == canid) {
+            // If found, call the event callback with the received data
+            CanEventStore[i].eventCall(canid ,data, len);
+            return;
+        }
+    }
+}

Application/Tasks/CanDataHandler.h

@@ -0,0 +1,114 @@
+/**
+ * @file CanDataHandler.h
+ * @brief CanDataHandler Module
+ *
+ * The CanDataHandler module is responsible for managing CAN data messages and event messages.
+ * It provides functionality to register CAN IDs for data and event messages, handle reception 
+ * of these messages from FIFO buffers, insert data messages into an array, and retrieve stored 
+ * data messages based on their CAN ID. 
+ *
+ * The module maintains an internal data structure for data and event message slots, each of which 
+ * is associated with a filter reference that points to a filter slot. A filter slot stores the 
+ * CAN IDs and indicates the type of FIFO buffer and the number of free IDs in the slot. 
+ *
+ * For event messages, a callback function can be registered to handle specific events associated 
+ * with a CAN ID.
+ */
+
+
+#ifndef CANDATAHANDLER_H
+#define CANDATAHANDLER_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include "fdcan.h"
+
+// Define the maximum length of data for a Data Message
+#define MAX_DATA_LENGTH 8
+
+typedef uint16_t CanDataId; 
+
+// Typedef for the event callback function
+typedef void (*EventCallback)(CanDataId canid, uint8_t* data, uint8_t len);
+
+
+// type of fifo that this slot uses
+typedef enum {
+    CANDATA_FIFOX_UNDEFIEND = FDCAN_FILTER_DISABLE,
+    CANDATA_FIFO0_DATA = FDCAN_FILTER_TO_RXFIFO0,
+    CANDATA_FIFO1_EVENT = FDCAN_FILTER_TO_RXFIFO1,
+} CanDataSlotFifo;
+
+// count of free ids in the slot
+typedef enum {
+    CANDATA_ALLFREE = 0,
+    CANDATA_FREE1 = 1,
+    CANDATA_FREE0 = 2,
+    CANDATA_FULL = 3,
+} CanDataSlotFree;
+
+// Define s structer for a used filter slot
+typedef struct {
+    CanDataSlotFree free; // Number of free IDs in the slot
+    CanDataSlotFifo fifo; // Type of FIFO that this slot uses
+    CanDataId id[2]; // Array to store the two CAN IDs associated with this filter slot
+} CanDataFilterSlot;
+
+
+
+// Define a structure for a Data Message
+typedef struct {
+    CanDataId canid;
+    uint8_t data[MAX_DATA_LENGTH];
+    uint8_t data_length;
+} CanDataMessage;
+
+typedef struct 
+{
+    CanDataFilterSlot * ref; // Reference to the filter slot
+    uint8_t index; // Index of the used CAN ID in the filter slot's id array
+} CanDataFilterRef;
+
+
+typedef struct {
+    CanDataMessage msg;
+    CanDataFilterRef filter;  // Filter reference
+} CanDataMessageSlot;
+
+
+// Define a structure for a Event Message
+typedef struct {
+    CanDataId canid;
+    EventCallback eventCall;
+    CanDataFilterRef filter;  // Filter reference
+} CanDataEventSlot;
+
+
+// reset all internal structures
+// does not reset CAN HW
+void CanDataHandler_init(void);
+
+// Function to register a CAN ID for Data Messages
+bool CanData_regDataMsg(CanDataId canid);
+
+// Function to register a CAN ID for Event Messages and associate it with a callback function
+bool CanData_regEventMsg(CanDataId canid, EventCallback event_callback);
+
+// Function to remove a CAN ID from Event Messages Register
+bool CanData_removeEvent(CanDataId canid);
+
+// Function to handle reception of Data Messages from FIFO0
+void CanData_canFifo0RxCallback(CanDataId canid, uint8_t* data, uint8_t len);
+
+// Function to handle reception of Event Messages from FIFO1
+void CanData_canFifo1RxCallback(CanDataId canid, uint8_t* data, uint8_t len);
+
+// Function to insert a Data Message into the array
+void CanData_insertDataMessage(CanDataId canid, uint8_t* data, uint8_t data_length);
+
+// Function to read stored Data Message based on CAN ID
+// Returns a const pointer to the stored data or NULL if not found
+const CanDataMessage* CanData_getDataMessage(CanDataId canid);
+
+#endif // CANDATAHANDLER_H

Application/Tasks/CanDataTask.c

@@ -0,0 +1,108 @@
+#include "cmsis_os2.h"  // CMSIS-RTOS2 header file
+#include "CanDataTask.h"
+#include "fdcan.h"
+#include "CanDataHandler.h"
+#include "FreeRTOS.h"
+
+
+// Define thread flags
+#define FLAG_FDCAN_RX_FIFO0  (1<<0)
+#define FLAG_FDCAN_RX_FIFO1  (1<<1)
+
+
+// Memory for the task
+StaticTask_t CanDataTask_cb;
+uint32_t CanDataTask_stk[512];
+// Attributes for the task
+osThreadId_t CanDataTask_id;
+const osThreadAttr_t CanDataTask_attr = {
+  .name = "CanDataTask",
+  .attr_bits = 0U,
+  .cb_mem = &CanDataTask_cb,
+  .cb_size = sizeof(CanDataTask_cb),
+  .stack_mem = CanDataTask_stk,
+  .stack_size = sizeof(CanDataTask_stk),
+  .priority = osPriorityNormal,
+  .tz_module = 0U,
+  .reserved = 0U
+};
+
+
+uint32_t dlcDecode(uint32_t dlcCode) {
+    switch(dlcCode) {
+        case FDCAN_DLC_BYTES_0:  return 0;
+        case FDCAN_DLC_BYTES_1:  return 1;
+        case FDCAN_DLC_BYTES_2:  return 2;
+        case FDCAN_DLC_BYTES_3:  return 3;
+        case FDCAN_DLC_BYTES_4:  return 4;
+        case FDCAN_DLC_BYTES_5:  return 5;
+        case FDCAN_DLC_BYTES_6:  return 6;
+        case FDCAN_DLC_BYTES_7:  return 7;
+        case FDCAN_DLC_BYTES_8:  return 8;
+        case FDCAN_DLC_BYTES_12: return 12;
+        case FDCAN_DLC_BYTES_16: return 16;
+        case FDCAN_DLC_BYTES_20: return 20;
+        case FDCAN_DLC_BYTES_24: return 24;
+        case FDCAN_DLC_BYTES_32: return 32;
+        case FDCAN_DLC_BYTES_48: return 48;
+        case FDCAN_DLC_BYTES_64: return 64;
+        default: return 0; // Return 0 for unknown dlc
+    }
+}
+
+
+void CanDataTask_func(void *argument);
+
+void CanDataTask_start() {
+  // Task functionality here
+   CanDataTask_id = osThreadNew(CanDataTask_func, NULL, &CanDataTask_attr);
+}
+
+static FDCAN_RxHeaderTypeDef RxHeader;
+static uint8_t RxData[8];
+void CanDataTask_HandleFifo(uint32_t fifo) {
+    while (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan1, FDCAN_RX_FIFO0) > 0 ) {
+        if (HAL_FDCAN_GetRxMessage(&hfdcan1, fifo, &RxHeader, RxData) != HAL_OK) {
+            Error_Handler();
+        } else {
+            CanData_canFifo0RxCallback(RxHeader.Identifier,RxData, dlcDecode(RxHeader.DataLength));
+        }
+    }
+}
+
+// Function for the task
+void CanDataTask_func(void *argument) {
+    /* Configure global filter on FDCAN instanc:
+       Filter all remote frames with STD and EXT ID
+       Reject non matching frames with STD ID and EXT ID */
+    if (HAL_FDCAN_ConfigGlobalFilter(&hfdcan1, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE) != HAL_OK) {
+        Error_Handler();
+    }
+
+    /* Start the FDCAN module */
+    if (HAL_FDCAN_Start(&hfdcan1) != HAL_OK){
+        Error_Handler();
+    }
+
+
+    for(;;) {
+        // wait for interrupt event on any fifo
+        uint32_t flags = osThreadFlagsWait(FLAG_FDCAN_RX_FIFO0 | FLAG_FDCAN_RX_FIFO1, osFlagsWaitAny, osWaitForever);
+
+        // check the fifos for data and handle it if nessessay
+        CanDataTask_HandleFifo(FDCAN_RX_FIFO0);
+        CanDataTask_HandleFifo(FDCAN_RX_FIFO1);
+    }   
+
+}
+
+
+void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs) {
+    // Notify the thread
+    osThreadFlagsSet(CanDataTask_id, FLAG_FDCAN_RX_FIFO0);
+}
+
+void HAL_FDCAN_RxFifo1Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs) {
+    // Notify the thread
+    osThreadFlagsSet(CanDataTask_id, FLAG_FDCAN_RX_FIFO1);
+}