added CarCan tp CanDataTask

Application/Tasks/CanDataTask.c

@@ -28,6 +28,22 @@ const osThreadAttr_t CanDataTask_attr = {
   .priority = osPriorityNormal,
 };
 
+// Memory for the task
+StaticTask_t CarCanTask_cb;
+uint32_t CarCanTask_stk[256];
+// Attributes for the task
+osThreadId_t CarCanTask_id;
+const osThreadAttr_t CarCanTask_attr = {
+  .name = "CarCanTask",
+  .attr_bits = 0U,
+  .cb_mem = &CarCanTask_cb,
+  .cb_size = sizeof(CarCanTask_cb),
+  .stack_mem = CarCanTask_stk,
+  .stack_size = sizeof(CarCanTask_stk),
+  .priority = osPriorityNormal,
+};
+
+
 
 uint32_t dlcDecode(uint32_t dlcCode) {
     switch(dlcCode) {
@@ -53,14 +69,14 @@ uint32_t dlcDecode(uint32_t dlcCode) {
 
 
 void CanDataTask_func(void *argument);
+void CarCanTask_func(void *argument);
 
 void CanDataTask_start() {
   // Task functionality here
    CanDataTask_id = osThreadNew(CanDataTask_func, NULL, &CanDataTask_attr);
+   CarCanTask_id = osThreadNew(CarCanTask_func, NULL, &CarCanTask_attr);
 }
 
-static FDCAN_RxHeaderTypeDef RxHeader;
-static uint8_t RxData[8];
 
 // Function for the task
 void CanDataTask_func(void *argument) {
@@ -87,38 +103,109 @@ void CanDataTask_func(void *argument) {
         CanData_regDataMsg(GENERATE_CLS_ADDRESS(CLS_CODE_STATUS, i, CLS_CH_STA_HEATBEAT));
     }
     
-
+    FDCAN_RxHeaderTypeDef RxHeader;
+    uint8_t RxData[8];
 
     for(;;) {
         // wait for interrupt event on any fifo
         osThreadFlagsWait(FLAG_FDCAN_RX_FIFO0 | FLAG_FDCAN_RX_FIFO1, osFlagsWaitAny, osWaitForever);
         // check the fifos for data and handle it if nessessay
         while (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan1, FDCAN_RX_FIFO0) > 0 ) {
-        if (HAL_FDCAN_GetRxMessage(&hfdcan1, FDCAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK) {
+            if (HAL_FDCAN_GetRxMessage(&hfdcan1, FDCAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK) {
-            Error_Handler();
+                Error_Handler();
-        } else {
+            } else {
-            CanData_canFifo0RxCallback(RxHeader.Identifier,RxData, dlcDecode(RxHeader.DataLength));
+                CanData_canFifo0RxCallback(RxHeader.Identifier,RxData, dlcDecode(RxHeader.DataLength));
+            }
         }
-    }
+        while (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan1, FDCAN_RX_FIFO1) > 0 ) {
-         while (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan1, FDCAN_RX_FIFO1) > 0 ) {
+            if (HAL_FDCAN_GetRxMessage(&hfdcan1, FDCAN_RX_FIFO1, &RxHeader, RxData) != HAL_OK) {
-        if (HAL_FDCAN_GetRxMessage(&hfdcan1, FDCAN_RX_FIFO1, &RxHeader, RxData) != HAL_OK) {
+                Error_Handler();
-            Error_Handler();
+            } else {
-        } else {
+                CanData_canFifo1RxCallback(RxHeader.Identifier,RxData, dlcDecode(RxHeader.DataLength));
-            CanData_canFifo1RxCallback(RxHeader.Identifier,RxData, dlcDecode(RxHeader.DataLength));
+            }
         }
     }   
-    }   
 }
 
+static uint64_t last_car_message_time = UINT64_MAX;
+
+void CarCanTask_func(void *argument) {
+
+    // for testing accept all messages from the car can bus
+    if (HAL_FDCAN_ConfigGlobalFilter(&hfdcan2, FDCAN_ACCEPT_IN_RX_FIFO0, FDCAN_ACCEPT_IN_RX_FIFO0, FDCAN_REJECT_REMOTE, FDCAN_REJECT_REMOTE) != HAL_OK) {
+        Error_Handler();
+    }
+
+    /* Start the FDCAN module */
+    if (HAL_FDCAN_Start(&hfdcan2) != HAL_OK){
+        Error_Handler();
+    }
+
+    if(HAL_FDCAN_ActivateNotification(&hfdcan2,FDCAN_IT_RX_FIFO0_NEW_MESSAGE | FDCAN_IT_RX_FIFO1_NEW_MESSAGE, 0) != HAL_OK) {
+        Error_Handler();
+    }
+
+    FDCAN_RxHeaderTypeDef RxHeader;
+    uint8_t RxData[8];
+
+    for(;;) {
+        // wait for interrupt event on any fifo
+        osThreadFlagsWait(FLAG_FDCAN_RX_FIFO0 | FLAG_FDCAN_RX_FIFO1, osFlagsWaitAny, osWaitForever);
+        // check the fifos for data and handle it if nessessay
+        while (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan2, FDCAN_RX_FIFO0) > 0 ) {
+            if (HAL_FDCAN_GetRxMessage(&hfdcan2, FDCAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK) {
+                Error_Handler();
+            } else {
+                
+                // do something with the can data
+                last_car_message_time = osKernelGetTickCount();
+
+            }
+        }
+        while (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan2, FDCAN_RX_FIFO1) > 0 ) {
+            if (HAL_FDCAN_GetRxMessage(&hfdcan2, FDCAN_RX_FIFO1, &RxHeader, RxData) != HAL_OK) {
+                Error_Handler();
+            } else {
+
+                // do something with the can data
+                last_car_message_time = osKernelGetTickCount();
+
+            }
+        }
+    }   
+}
+
+/**
+ * @brief Check if a car can message has been received
+ * 
+ * @return true if a car can message has been received
+ * @return false if no car can message has been received
+ */
+bool CanDataTask_gotCarCanMessage() {
+    return last_car_message_time != UINT64_MAX;
+}
 
 void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs) {
     // Notify the thread
-    osThreadFlagsSet(CanDataTask_id, FLAG_FDCAN_RX_FIFO0);
+    if(hfdcan == &hfdcan1) {
+        osThreadFlagsSet(CanDataTask_id, FLAG_FDCAN_RX_FIFO0);
+    }
+
+    if(hfdcan == &hfdcan2) {
+        osThreadFlagsSet(CarCanTask_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);
+    if(hfdcan == &hfdcan1) {
+        osThreadFlagsSet(CanDataTask_id, FLAG_FDCAN_RX_FIFO1);
+    }
+
+    if(hfdcan == &hfdcan2) {
+        osThreadFlagsSet(CarCanTask_id, FLAG_FDCAN_RX_FIFO1);
+    }
 }
 
 

Application/Tasks/CanDataTask.h

@@ -1,3 +1,6 @@
 #pragma once
 
 void CanDataTask_start();
+
+
+bool CanDataTask_gotCarCanMessage();