Fix/rx handler

ThreadX_Os/CMakeLists.txt

@@ -50,7 +50,6 @@ target_sources(${CMAKE_PROJECT_NAME} PRIVATE
     Core/Src/threads/speedSensor.c
     Core/Src/threads/tx_can.c
     Core/Src/threads/rx_can.c
-    Core/Src/utils/rx_handler.c
     Core/Src/utils/speed_rpm.c
 )
 

ThreadX_Os/Core/Inc/app_threadx.h

@@ -49,7 +49,7 @@ typedef struct s_threads {
 // CAN frames structure
 typedef struct s_canFrames {
   FDCAN_TxHeaderTypeDef tx_header_speed;
-  FDCAN_TxHeaderTypeDef tx_header_steering_throttle;
+  FDCAN_TxHeaderTypeDef tx_header_heart_beat;
   FDCAN_TxHeaderTypeDef tx_header_battery;
 } t_canFrames;
 
@@ -98,6 +98,7 @@ void MX_ThreadX_Init(void);
 VOID  thread_SensorSpeed(ULONG thread_input);
 VOID  thread_tx_can(ULONG thread_input);
 VOID  thread_rx_can(ULONG thread_input);
+uint8_t rx_receive(t_rx_can_msg *msg);
 
 //init
 void  initCanFrames(t_canFrames *canFrames);
@@ -106,7 +107,6 @@ UINT  init_queue(VOID);
 
 //utils
 VOID  uart_send(const char *msg);
-UINT  rx_handler(const t_rx_can_msg *msg);
 
 /* USER CODE END EFP */
 

ThreadX_Os/Core/Inc/utils.h

@@ -13,13 +13,15 @@
 #endif
 
 // Timer ticks per second definition
-#define TX_TIMER_TICKS_PER_SECOND    1000
+#ifndef TX_TIMER_TICKS_PER_SECOND
+  #define TX_TIMER_TICKS_PER_SECOND    1000
+#endif
 
 // CAN message types
 typedef enum {
   CAN_MSG_SPEED,
-  CAN_MSG_STEERING_THROTTLE,
-  CAN_MSG_BATTERY
+  CAN_MSG_BATTERY,
+  CAN_MSG_HEARTBEAT,
 } e_can_msg_type;
 
 // TX CAN message structure
@@ -32,6 +34,7 @@ typedef struct s_tx_can_message {
 typedef struct s_rx_can_message {
   uint32_t       type;
   uint8_t        data[8];
+  uint8_t        len;
 } t_rx_can_msg;
 
 //Maximum RPM value to prevent overflow
@@ -53,6 +56,4 @@ UINT    convertValuesRPM(
     ULONG period,
     t_rpm_state *state);
 
-UINT    rx_handler(const t_rx_can_msg *msg);
-
 #endif

ThreadX_Os/Core/Src/init/init_can.c

@@ -1,18 +1,18 @@
 #include "app_threadx.h"
 
+static void TxHeartBeatConf(FDCAN_TxHeaderTypeDef *TxHeader);
 static void TxSpeedConf(FDCAN_TxHeaderTypeDef *TxHeader);
-static void TxSteeringThrottleConf(FDCAN_TxHeaderTypeDef *TxHeader);
 static void TxBatteryConf(FDCAN_TxHeaderTypeDef *TxHeader);
 
 // Configuration of CAN frame for speed data
 void initCanFrames(t_canFrames *canFrames) 
 {
+    TxHeartBeatConf(&canFrames->tx_header_heart_beat);
     TxSpeedConf(&canFrames->tx_header_speed);
-    TxSteeringThrottleConf(&canFrames->tx_header_steering_throttle);
     TxBatteryConf(&canFrames->tx_header_battery);
 }
 
-static void    TxSpeedConf(FDCAN_TxHeaderTypeDef *TxHeader) 
+static void    TxHeartBeatConf(FDCAN_TxHeaderTypeDef *TxHeader) 
 {
     TxHeader->Identifier = 0x200;
     TxHeader->IdType = FDCAN_STANDARD_ID;
@@ -25,7 +25,7 @@ static void    TxSpeedConf(FDCAN_TxHeaderTypeDef *TxHeader)
     TxHeader->MessageMarker = 0x0;
 }
 
-static void    TxSteeringThrottleConf(FDCAN_TxHeaderTypeDef *TxHeader) 
+static void    TxSpeedConf(FDCAN_TxHeaderTypeDef *TxHeader) 
 {
     TxHeader->Identifier = 0x201;
     TxHeader->IdType = FDCAN_STANDARD_ID;

ThreadX_Os/Core/Src/threads/rx_can.c

@@ -1,35 +1,50 @@
 #include "app_threadx.h"
 
-// CALLBACK - automatically called by the interrupt when a CAN message arrives
-void    HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)
+// CAN RX callback function
+uint8_t rx_receive(t_rx_can_msg *msg)
 {
-    static FDCAN_RxHeaderTypeDef rxHeader;
-    static t_rx_can_msg          msg;
+    FDCAN_RxHeaderTypeDef   rxHeader;
+    uint8_t                 rx_data[8];
 
-    uart_send("CAN RX Callback triggered\r\n");
-    if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_NEW_MESSAGE) != 0)
+    if (HAL_FDCAN_GetRxFifoFillLevel(&hfdcan1, FDCAN_RX_FIFO0) > 0)
     {
-        if (HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &rxHeader, msg.data) == HAL_OK)
+        if (HAL_FDCAN_GetRxMessage(&hfdcan1, FDCAN_RX_FIFO0, &rxHeader, rx_data) == HAL_OK)
         {
-            msg.type = rxHeader.Identifier;
-            tx_queue_send(&can_rx_queue, &msg, TX_NO_WAIT);
+            msg->type = rxHeader.Identifier;
+            msg->len = (rxHeader.DataLength <= 8) ? rxHeader.DataLength : 8;
+            memcpy(msg->data, rx_data, msg->len);
+            return (1); // Success
         }
     }
+    return (0); // Failure
 }
 
-// THREAD - responsible to receive CAN messages from the RX queue and process them
+// THREAD - responsible to receive CAN messages
 VOID    thread_rx_can(ULONG thread_input)
 {
     t_rx_can_msg    msg;
+    memset(&msg, 0, sizeof(t_rx_can_msg));
+
+    uart_send("CAN RX thread started\r\n");
     while (1)
     {
-        // constant wait for incoming messages
-        if (tx_queue_receive(&can_rx_queue, &msg, TX_WAIT_FOREVER) == TX_SUCCESS)
+        if (rx_receive(&msg)) 
         {
-            if (rx_handler(&msg) != TX_SUCCESS)
-                uart_send("Error processing CAN RX message\r\n");
-            else
-                uart_send("CAN RX message processed successfully\r\n");
+            switch(msg.type) 
+            {
+                case 0x100: // Emergency break
+                    tx_queue_send(&can_rx_queue, &msg, TX_NO_WAIT);
+                    uart_send("Received Emergency break msg\r\n");
+                    break ;
+                case 0x101: // Steering and throttle
+                    tx_queue_send(&can_rx_queue, &msg, TX_NO_WAIT);
+                    uart_send("Received CAN MSG STEERING THROTTLE\r\n");
+                    break ;
+                default:
+                    uart_send("Received UNKNOWN CAN MSG\r\n");
+                    break ;
+            }
         }
+        tx_thread_sleep(1);
     }
 }

ThreadX_Os/Core/Src/threads/speedSensor.c

@@ -39,7 +39,7 @@ VOID thread_SensorSpeed(ULONG thread_input)
         rpm = convertValuesRPM(count, ticks, period, &state);
 
         // Debug
-        rpm_debug_print(rpm, cr1_reg, count);
+        //rpm_debug_print(rpm, cr1_reg, count);
 
         // Division of RPM into two data bytes *(big-endian)*
         msg.data[0] = (rpm >> 8) & 0xFF;
@@ -50,10 +50,10 @@ VOID thread_SensorSpeed(ULONG thread_input)
         if (ret != TX_SUCCESS)
         {
             uart_send("CAN TX could not add message to queue!\r\n");
-            tx_thread_sleep(500);
+            tx_thread_sleep(200);
             continue ;
         }
-        tx_thread_sleep(500);
+        tx_thread_sleep(400);
     }
 }
 

ThreadX_Os/Core/Src/threads/tx_can.c

@@ -11,9 +11,9 @@ VOID thread_tx_can(ULONG thread_input)
     memset(&msg, 0, sizeof(t_tx_can_msg));
     memset(&canFrames, 0, sizeof(t_canFrames));
     initCanFrames(&canFrames);
-    if (canFrames.tx_header_speed.Identifier == 0 &&
-            canFrames.tx_header_steering_throttle.Identifier == 0 &&
-            canFrames.tx_header_battery.Identifier == 0) {
+    if (!canFrames.tx_header_speed.Identifier ||
+            !canFrames.tx_header_heart_beat.Identifier ||
+            !canFrames.tx_header_battery.Identifier) {
         uart_send("CAN frames not initialized!\r\n");
         return ;
     }
@@ -30,23 +30,23 @@ VOID thread_tx_can(ULONG thread_input)
                     &canFrames.tx_header_speed,
                     msg.data
                 );
-                uart_send("Speed CAN message sent\r\n");
-                break;
-
-                case CAN_MSG_STEERING_THROTTLE:
+                    uart_send("Speed CAN message sent\r\n");
+                    break;
+                case CAN_MSG_HEARTBEAT:
                     HAL_FDCAN_AddMessageToTxFifoQ(
                         &hfdcan1,
-                        &canFrames.tx_header_steering_throttle,
+                        &canFrames.tx_header_heart_beat,
                         msg.data
                     );
+                    uart_send("Heart Beat CAN message sent\r\n");
                     break;
-
                 case CAN_MSG_BATTERY:
                     HAL_FDCAN_AddMessageToTxFifoQ(
                         &hfdcan1,
                         &canFrames.tx_header_battery,
                         msg.data
                     );
+                    uart_send("Battery CAN message sent\r\n");
                     break;
                 default:
                     uart_send("Unknown CAN message type\r\n");