Initialize cansend headers

- This is efficient specifically for
  STM32F4x with Thumb-2 IT block
  optimization enabled (-02 or -03)

Core/Inc/cansend.h

@@ -0,0 +1,29 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file           : CANSEND.h
+  * @brief          : Header for cansend.c file.
+  *                   This file contains the defines related to CAN data sent
+  *                   via UART/USART and save via SDIO.
+  ******************************************************************************
+  * @attention
+  *
+  * Copyright (c) 2026 Erick Ahmed.
+  *
+  * SPDX-License-Identifier: GPL-3.0-or-later
+  *
+  ******************************************************************************
+  */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef CANSEND_H
+#define CANSEND_H
+
+
+
+
+
+
+
+#endif /* CANSEND_H */

Core/Src/canlog.c

@@ -24,8 +24,10 @@
 extern CAN_HandleTypeDef hcan1;
 extern CAN_HandleTypeDef hcan2;
 
-extern osThreadId_t xLedTaskCAN1;
-extern osThreadId_t xLedTaskCAN2;
+extern osThreadId_t xCAN1LedTask;
+extern osThreadId_t xCAN2LedTask;
+
+extern osEventFlagsId_t xCanEventFlags;
 
 /* Private function prototypes -----------------------------------------------*/
 /* USER CODE BEGIN FunctionPrototypes */
@@ -71,6 +73,10 @@ void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
     CAN_RxHeaderTypeDef rxHeader;
     uint8_t data[8];
 
+    osMessageQueueId_t queue;
+    uint32_t flag;
+    osThreadId_t led_task;
+
     // TODO: manage the case of FIFO overflow
     if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &rxHeader, data) != HAL_OK) return;
 
@@ -79,11 +85,23 @@ void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
     message.isExtended = (rxHeader.IDE == CAN_ID_EXT);
     memcpy(message.payload, data, rxHeader.DLC);
 
-    osMessageQueueId_t queue = (hcan->Instance == CAN1) ? xCAN1RxQueue : xCAN2RxQueue;
+    if (hcan->Instance == CAN1)
+    {
+        queue    = xCAN1RxQueue;
+        flag     = 0x01;
+        led_task = xCAN1LedTask;
+    }
+    else
+    {
+        queue    = xCAN2RxQueue;
+        flag     = 0x02;
+        led_task = xCAN2LedTask;
+    }
+
     if (osMessageQueuePut(queue, &message, 0U, 0U) == osOK)
     {
-      if (hcan->Instance == CAN1) osThreadFlagsSet(xLedTaskCAN1, 0x01);
-      else osThreadFlagsSet(xLedTaskCAN2, 0x01);
+        osEventFlagsSet(xCanEventFlags, flag);
+        osThreadFlagsSet(led_task, 0x01);
     }
     else
     {
@@ -114,7 +132,7 @@ void vCANLoggerListen(void *argument)
   {
     if (osMessageQueueGet(queue, &message, NULL, osWaitForever) == osOK)
 	{
-					//
+
 	}
   }
 	/* CODE END */

Core/Src/cansend.c

@@ -0,0 +1,24 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file           : cansend.c
+  * @brief          : Send logged SAE J1939 CAN via serial and save via SDIO.
+  ******************************************************************************
+  * @attention
+  *
+  * Copyright (c) 2026 Erick Ahmed.
+  *
+  * SPDX-License-Identifier: GPL-3.0-or-later
+  *
+  ******************************************************************************
+  */
+/* USER CODE END Header */
+/* Includes ------------------------------------------------------------------*/
+#include "cansend.h"
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+#include "cmsis_os.h"
+/* USER CODE END Includes */
+
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
+void vUARTLogger(void *argument);

Core/Src/main.c

@@ -20,6 +20,7 @@
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
 #include "canlog.h"
+#include "cansend.h"
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -53,6 +54,10 @@ LED_Config led_error = {GPIOB, GPIO_PIN_3};
 
 osMessageQueueId_t xCAN1RxQueue;
 osMessageQueueId_t xCAN2RxQueue;
+
+osEventFlagsId_t xCanEventFlags;
+osSemaphoreId_t xUARTDMASemaphore;
+osThreadId_t xUartTask;
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -114,28 +119,34 @@ int main(void)
   osKernelInitialize();
 
   /* USER CODE BEGIN RTOS_TASKS */
-  osThreadId_t xCAN1rx;
+  osThreadId_t xCAN1rxTask;
   const osThreadAttr_t CAN1rxAttributes = {
     .name = "CAN1rx",
     .stack_size = 128 * 4,
     .priority = (osPriority_t) osPriorityRealtime1,
   };
 
-  osThreadId_t xCAN2rx;
+  osThreadId_t xCAN2rxTask;
   const osThreadAttr_t CAN2rxAttributes = {
     .name = "CAN2rx",
     .stack_size = 128 * 4,
     .priority = (osPriority_t) osPriorityRealtime,
   };
 
-  osThreadId_t xLedTaskCAN1;
+  const osThreadAttr_t UartLoggerAttributes = {
+    .name = "UART_Logger",
+    .stack_size = 256 * 4,
+    .priority = (osPriority_t) osPriorityVeryHigh,
+  };
+
+  osThreadId_t xCAN1LedTask;
   const osThreadAttr_t LEDHeartbeatCAN1Attributes = {
     .name = "LED_HB_CAN1",
     .stack_size = 128 * 4,
     .priority = (osPriority_t) osPriorityVeryLow1,
   };
 
-  osThreadId_t xLedTaskCAN2;
+  osThreadId_t xCAN2LedTask;
   const osThreadAttr_t LEDHeartbeatCAN2Attributes = {
     .name = "LED_HB_CAN2",
     .stack_size = 128 * 4,
@@ -147,6 +158,8 @@ int main(void)
   /* USER CODE END RTOS_MUTEX */
 
   /* USER CODE BEGIN RTOS_SEMAPHORES */
+  xUARTDMASemaphore = osSemaphoreNew(1, 0, NULL);
+  if (xUARTDMASemaphore == NULL) Error_Handler();
   /* USER CODE END RTOS_SEMAPHORES */
 
   /* USER CODE BEGIN RTOS_TIMERS */
@@ -160,13 +173,16 @@ int main(void)
   /* USER CODE END RTOS_QUEUES */
 
   /* USER CODE BEGIN RTOS_THREADS */
-  xCAN1rx = osThreadNew(vCANLoggerListen, &hcan1, &CAN1rxAttributes);
-  xCAN2rx = osThreadNew(vCANLoggerListen, &hcan2, &CAN2rxAttributes);
-  xLedTaskCAN1 = osThreadNew(vLEDHeartbeat, &led_can1, &LEDHeartbeatCAN1Attributes);
-  xLedTaskCAN2 = osThreadNew(vLEDHeartbeat, &led_can2, &LEDHeartbeatCAN2Attributes);
+  xCAN1rxTask = osThreadNew(vCANLoggerListen, &hcan1, &CAN1rxAttributes);
+  xCAN2rxTask = osThreadNew(vCANLoggerListen, &hcan2, &CAN2rxAttributes);
+  xUartTask = osThreadNew(vUARTLogger, NULL, &UartLoggerAttributes);
+  xCAN1LedTask = osThreadNew(vLEDHeartbeat, &led_can1, &LEDHeartbeatCAN1Attributes);
+  xCAN2LedTask = osThreadNew(vLEDHeartbeat, &led_can2, &LEDHeartbeatCAN2Attributes);
   /* USER CODE END RTOS_THREADS */
 
   /* USER CODE BEGIN RTOS_EVENTS */
+  xCanEventFlags = osEventFlagsNew(NULL);
+  if (xCanEventFlags == NULL) Error_Handler();
   /* USER CODE END RTOS_EVENTS */
 
   /* Start scheduler */