Put in normal mode to avoid blocking ACK sending

- No transmitter side clock error in this way

Core/Inc/cansend.h

@@ -22,6 +22,7 @@
 
 #include "main.h"
 
+void uart_printf(const char *fmt, ...);
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
 void vUARTLogger(void *argument);
 

Core/Inc/main.h

@@ -45,18 +45,15 @@ extern "C" {
 
 /* Exported macro ------------------------------------------------------------*/
 /* USER CODE BEGIN EM */
-//#define DEBUG_ITW
+//#define DEBUG_ITM
-//#define DEBUG_DUMMY_FRAME
+#define DEBUG_DUMMY_FRAME
 
-#ifdef DEBUG_ITW
+#ifdef DEBUG_ITM
 #include <stdio.h>
 #define DEBUG_PRINT(...) printf(__VA_ARGS__)
 #else
-#include <stdarg.h>
+#define DEBUG_PRINT(...) uart_printf(__VA_ARGS__)
-void uart_debug_print(const char *fmt, ...);
-#define DEBUG_PRINT(...) uart_debug_print(__VA_ARGS__)
 #endif
-
 /* USER CODE END EM */
 
 /* Exported functions prototypes ---------------------------------------------*/

Core/Src/canlog.c

@@ -18,6 +18,7 @@
 #include "main.h"
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
+#include "cansend.h"
 #include "cmsis_os.h"
 #include <string.h>
 /* USER CODE END Includes */
@@ -28,9 +29,6 @@ extern CAN_HandleTypeDef hcan2;
 extern osThreadId_t xCAN1LedTask;
 extern osThreadId_t xCAN2LedTask;
 
-volatile uint32_t can1_rx_isr_count = 0;
-volatile uint32_t can2_rx_isr_count = 0;
-
 /* Private function prototypes -----------------------------------------------*/
 /* USER CODE BEGIN FunctionPrototypes */
 /**
@@ -54,6 +52,7 @@ void CAN_Logger_Init(CAN_HandleTypeDef *hcan1, CAN_HandleTypeDef *hcan2)
 
     filter.FilterBank = 0;
     if (HAL_CAN_ConfigFilter(hcan1, &filter) != HAL_OK) Error_Handler();
+
     filter.FilterBank = 14;
     if (HAL_CAN_ConfigFilter(hcan2, &filter) != HAL_OK) Error_Handler();
 }
@@ -67,9 +66,6 @@ void CAN_Logger_Init(CAN_HandleTypeDef *hcan1, CAN_HandleTypeDef *hcan2)
   */
 void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
 {
-  if (hcan->Instance == CAN1) can1_rx_isr_count++;
-  else can2_rx_isr_count++;
-
     CanMessage_t message;
     CAN_RxHeaderTypeDef rxHeader;
     uint8_t data[8];
@@ -118,7 +114,7 @@ void vCANListener(void *argument)
   HAL_CAN_ActivateNotification(hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
 
   uint32_t irqn = (hcan->Instance == CAN1) ? CAN1_RX0_IRQn : CAN2_RX0_IRQn;
-  HAL_NVIC_SetPriority(irqn, 6, 0);
+  HAL_NVIC_SetPriority(irqn, 5, 0);
   HAL_NVIC_EnableIRQ(irqn);
 
   for (;;)
@@ -129,14 +125,13 @@ void vCANListener(void *argument)
 
       osMessageQueuePut(xUARTQueue, &message, 0U, 0U);
     }
-    else DEBUG_PRINT("LALALLALA CIAOOOOOO c:\r\n");
   }
 }
 /* END vCANListener */
 
 /* BEGIN vLEDHeartbeat */
 /**
-  * @brief  Blink a LED in heartbeat mode when CAN traffic is detected
+  * @brief  Turn on LED when CAN traffic is detected
   * @param  argument: LED GPIO (port and pin)
   * @retval None
   */

Core/Src/cansend.c

@@ -22,15 +22,47 @@
 #include "canlog.h"
 #include <stdio.h>
 #include <stdarg.h>
+#include "cmsis_os.h"
+#include "stm32f4xx.h"
 /* USER CODE END Includes */
 
 extern UART_HandleTypeDef huart1;
 extern osSemaphoreId_t xUARTDMASemaphore;
 extern osMessageQueueId_t xUARTQueue;
-extern volatile uint32_t can1_rx_isr_count;
+extern UART_HandleTypeDef huart1;
-extern volatile uint32_t can2_rx_isr_count;
+extern osSemaphoreId_t xUARTDMASemaphore;
-extern CAN_HandleTypeDef hcan1;
+
-extern CAN_HandleTypeDef hcan2;
+/* BEGIN uart_printf */
+/**
+  * @brief  Implementation of a simple print to UART.
+  * @param  arguments: strings to print
+  * @retval None
+  */
+void uart_printf(const char *fmt, ...)
+{
+  static char buf[128];
+  va_list args;
+  va_start(args, fmt);
+  int len = vsnprintf(buf, sizeof(buf), fmt, args);
+  va_end(args);
+
+  if (len > 0)
+  {
+    if (osKernelGetState() == osKernelRunning && __get_IPSR() == 0)
+    {
+      if (osSemaphoreAcquire(xUARTDMASemaphore, 100U) == osOK)
+      {
+        HAL_UART_Transmit(&huart1, (uint8_t*)buf, len, HAL_MAX_DELAY);
+        osSemaphoreRelease(xUARTDMASemaphore);
+      }
+    }
+    else
+    {
+      HAL_UART_Transmit(&huart1, (uint8_t*)buf, len, HAL_MAX_DELAY);
+    }
+  }
+}
+/* END uart_printf */
 
 /* BEGIN format_can_message */
 /**
@@ -92,10 +124,35 @@ static int format_can_message(char *buf, uint8_t source, const CanMessage_t *mes
   */
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 {
+  if (huart->Instance == USART1) osSemaphoreRelease(xUARTDMASemaphore);
 }
 /* END HAL_UART_TxCpltCallback */
 
-/* BEGIN vUARTLoggerListen */
+/* BEGIN HAL_UART_ErrorCallback */
+/**``MEN
+  * @brief  Handle UART errors
+  * @param  argument: UART handle
+  * @retval None
+  */
+void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
+{
+  if (huart->Instance == USART1)
+  {
+    __HAL_UART_CLEAR_OREFLAG(huart);
+    __HAL_UART_CLEAR_FEFLAG(huart);
+    __HAL_UART_CLEAR_NEFLAG(huart);
+    __HAL_UART_CLEAR_PEFLAG(huart);
+
+    HAL_UART_DMAStop(huart);
+
+    huart->gState = HAL_UART_STATE_READY;
+
+    osSemaphoreRelease(xUARTDMASemaphore);
+  }
+}
+/* END HAL_UART_ErrorCallback */
+
+/* BEGIN vUARTLogger */
 /**
   * @brief  Send CAN bus traffic saved in FIFO buffer to USART1
   * @param  argument: Not used
@@ -104,9 +161,7 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 void vUARTLogger(void *argument)
 {
   CanMessage_t message;
-
   static char tx_buffer[45];
-  static char diag_buf[128];
 
   #ifdef DEBUG_DUMMY_FRAME
   CanMessage_t dummy_frame = {
@@ -120,37 +175,21 @@ void vUARTLogger(void *argument)
 
   for (;;)
   {
-    uint32_t queue_timeout = 1000U;
+    if (osMessageQueueGet(xUARTQueue, &message, NULL, 1000U) == osOK)
-
-    //ALT: uint32_t queue_timeout = osWaitForever;
-
-    #ifdef DEBUG_DUMMY_FRAME
-    osMessageQueuePut(xCAN1RxQueue, &dummy_frame, 0U, 0U);
-    osDelay(1000);
-    #endif
-
-    if (osMessageQueueGet(xUARTQueue, &message, NULL, queue_timeout) == osOK)
     {
-      if (huart1.gState != HAL_UART_STATE_READY)
+      if (osSemaphoreAcquire(xUARTDMASemaphore, 100U) == osOK)
       {
-        HAL_UART_Abort(&huart1);
-        HAL_UART_Init(&huart1);
-      }
-
-      osSemaphoreAcquire(xUARTDMASemaphore, osWaitForever);
-
         int len = format_can_message(tx_buffer, message.source, &message);
-      HAL_UART_Transmit(&huart1, (uint8_t*)tx_buffer, len, 100);
 
-      osSemaphoreRelease(xUARTDMASemaphore);
+        if (HAL_UART_Transmit_DMA(&huart1, (uint8_t*)tx_buffer, len) != HAL_OK)
-    }
-    else
         {
-      DEBUG_PRINT("[D] ISR1:%lu ISR2:%lu | ST1:%lu ST2:%lu | ER1:0x%lX ER2:0x%lX\r\n",
+          osSemaphoreRelease(xUARTDMASemaphore);
-          (unsigned long)can1_rx_isr_count, (unsigned long)can2_rx_isr_count,
+          DEBUG_PRINT("[E] HAL error, CAN frame NOT sent!\r\n");
-          (unsigned long)HAL_CAN_GetState(&hcan1), (unsigned long)HAL_CAN_GetState(&hcan2),
-          (unsigned long)HAL_CAN_GetError(&hcan1), (unsigned long)HAL_CAN_GetError(&hcan2));
         }
       }
+      else DEBUG_PRINT("[E] Semaphore timeout! UART might be stuck in BUSY state.\r\n");
 	}
-/* END vUARTLoggerListen */
+   	else DEBUG_PRINT("[D] Waiting for CAN traffic...\r\n");
+  }
+}
+/* END vUARTLogger */

Core/Src/main.c

@@ -21,8 +21,6 @@
 /* USER CODE BEGIN Includes */
 #include "canlog.h"
 #include "cansend.h"
-#include <stdio.h>
-#include <stdarg.h>
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -55,8 +53,6 @@ LED_Config led_can1 = {GPIOB, GPIO_PIN_5};
 LED_Config led_can2 = {GPIOB, GPIO_PIN_6};
 LED_Config led_error = {GPIOB, GPIO_PIN_7};
 
-osMutexId_t debugPrintMutex;
-
 osThreadId_t xCAN1rxTask;
 osThreadId_t xCAN2rxTask;
 osThreadId_t xCAN1LedTask;
@@ -68,6 +64,7 @@ osMessageQueueId_t xUARTQueue;
 
 osSemaphoreId_t xUARTDMASemaphore;
 osThreadId_t xUartTask;
+
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -78,43 +75,16 @@ static void MX_CAN1_Init(void);
 static void MX_CAN2_Init(void);
 static void MX_SDIO_SD_Init(void);
 static void MX_USART1_UART_Init(void);
-/* USER CODE END PFP */
 
-/* USER CODE BEGIN PF */
+void uart_printf(const char *fmt, ...);
+
+/* USER CODE BEGIN PFP */
 int _write(int file, char *ptr, int len)
 {
-  if (osKernelGetState() == osKernelRunning) osSemaphoreAcquire(xUARTDMASemaphore, osWaitForever);
+  for (int i = 0; i < len; i++) ITM_SendChar((*ptr++));
-  HAL_UART_Transmit(&huart1, (uint8_t*)ptr, len, 100);
-
-  if (osKernelGetState() == osKernelRunning) osSemaphoreRelease(xUARTDMASemaphore);
   return len;
 }
-
+/* USER CODE END PFP */
-#ifndef DEBUG_ITW
-#include <stdio.h>
-#include <stdarg.h>
-
-extern osSemaphoreId_t xUARTDMASemaphore;
-
-void uart_debug_print(const char *fmt, ...)
-{
-  if (huart1.gState == HAL_UART_STATE_RESET) return;
-
-  if (osKernelGetState() == osKernelRunning) osSemaphoreAcquire(xUARTDMASemaphore, osWaitForever);
-
-  char buf[128];
-  va_list args;
-
-  va_start(args, fmt);
-  int len = vsnprintf(buf, sizeof(buf), fmt, args);
-  va_end(args);
-
-  if (len > 0) HAL_UART_Transmit(&huart1, (uint8_t*)buf, len, 100);
-
-  if (osKernelGetState() == osKernelRunning) osSemaphoreRelease(xUARTDMASemaphore);
-}
-#endif
-/* USER CODE END PF */
 
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
@@ -141,6 +111,7 @@ int main(void)
 
   /* MCU Configuration--------------------------------------------------------*/
 
+  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   HAL_Init();
 
   /* USER CODE BEGIN Init */
@@ -156,12 +127,12 @@ int main(void)
   /* USER CODE END SysInit */
 
   /* Initialize all configured peripherals */
-  MX_GPIO_Init();
   MX_DMA_Init();
+  MX_GPIO_Init();
+  MX_USART1_UART_Init();
   MX_CAN1_Init();
   MX_CAN2_Init();
   MX_SDIO_SD_Init();
-  MX_USART1_UART_Init();
   /* USER CODE BEGIN 2 */
   DEBUG_PRINT("[L] Initializing CAN bus logger\r\n");
   CAN_Logger_Init(&hcan1, &hcan2);
@@ -201,8 +172,6 @@ int main(void)
   /* USER CODE END RTOS_TASKS */
 
   /* USER CODE BEGIN RTOS_MUTEX */
-  debugPrintMutex = osMutexNew(NULL);
-  if (debugPrintMutex == NULL) Error_Handler();
   /* USER CODE END RTOS_MUTEX */
 
   /* USER CODE BEGIN RTOS_SEMAPHORES */
@@ -227,6 +196,9 @@ int main(void)
   xUartTask = osThreadNew(vUARTLogger, NULL, &UartLoggerAttributes);
   xCAN1LedTask = osThreadNew(vLEDHeartbeat, &led_can1, &LEDHeartbeatCAN1Attributes);
   xCAN2LedTask = osThreadNew(vLEDHeartbeat, &led_can2, &LEDHeartbeatCAN2Attributes);
+
+  if (xCAN1rxTask == NULL || xCAN2rxTask == NULL || xUartTask == NULL ||
+      xCAN1LedTask == NULL || xCAN2LedTask == NULL) Error_Handler();
   /* USER CODE END RTOS_THREADS */
 
   /* USER CODE BEGIN RTOS_EVENTS */
@@ -313,7 +285,7 @@ static void MX_CAN1_Init(void)
   /* USER CODE END CAN1_Init 1 */
   hcan1.Instance = CAN1;
   hcan1.Init.Prescaler = 4;
-  hcan1.Init.Mode = CAN_MODE_SILENT;
+  hcan1.Init.Mode = CAN_MODE_NORMAL;
   hcan1.Init.SyncJumpWidth = CAN_SJW_1TQ;
   hcan1.Init.TimeSeg1 = CAN_BS1_16TQ;
   hcan1.Init.TimeSeg2 = CAN_BS2_4TQ;
@@ -350,7 +322,7 @@ static void MX_CAN2_Init(void)
   /* USER CODE END CAN2_Init 1 */
   hcan2.Instance = CAN2;
   hcan2.Init.Prescaler = 8;
-  hcan2.Init.Mode = CAN_MODE_SILENT;
+  hcan2.Init.Mode = CAN_MODE_NORMAL;
   hcan2.Init.SyncJumpWidth = CAN_SJW_1TQ;
   hcan2.Init.TimeSeg1 = CAN_BS1_16TQ;
   hcan2.Init.TimeSeg2 = CAN_BS2_4TQ;
@@ -401,7 +373,7 @@ static void MX_SDIO_SD_Init(void)
   //  Error_Handler();
   //}
   /* USER CODE BEGIN SDIO_Init 2 */
-  //DEBUG_PRINT("SDIO initialized!\r\n");
+  //DEBUG_PRINT("[L] SDIO initialized\r\n");
   /* USER CODE END SDIO_Init 2 */
 
 }
@@ -422,11 +394,11 @@ static void MX_USART1_UART_Init(void)
 
   /* USER CODE END USART1_Init 1 */
   huart1.Instance = USART1;
-  huart1.Init.BaudRate = 1152000;
+  huart1.Init.BaudRate = 1000000;
   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   huart1.Init.StopBits = UART_STOPBITS_1;
   huart1.Init.Parity = UART_PARITY_NONE;
-  huart1.Init.Mode = UART_MODE_TX_RX;
+  huart1.Init.Mode = UART_MODE_TX;
   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
   if (HAL_UART_Init(&huart1) != HAL_OK)
@@ -529,6 +501,22 @@ static void MX_GPIO_Init(void)
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
+  //*Configure CAN1 pins : PB8, PB9 */
+  GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9;
+  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+  GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+  //*Configure CAN2 pins : PB12, PB13 */
+  GPIO_InitStruct.Pin = GPIO_PIN_12 | GPIO_PIN_13;
+  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+  GPIO_InitStruct.Alternate = GPIO_AF9_CAN2;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
   /* USER CODE BEGIN MX_GPIO_Init_2 */
   DEBUG_PRINT("[L] GPIO initialized\r\n");
   /* USER CODE END MX_GPIO_Init_2 */
@@ -565,29 +553,32 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   */
 void Error_Handler(void)
 {
-  DEBUG_PRINT("[E] Eentering error handler\r\n");
+  DEBUG_PRINT("[E] Entering error handler\r\n");
 
   /* USER CODE BEGIN Error_Handler_Debug */
   /* User can add his own implementation to report the HAL error return state */
+  if (HAL_CAN_GetState(&hcan1) != HAL_CAN_STATE_READY)
+  {
+    DEBUG_PRINT("[E] CAN1 error code: 0x%08lX\r\n", (unsigned long)HAL_CAN_GetError(&hcan1));
+  }
+  if (HAL_CAN_GetState(&hcan2) != HAL_CAN_STATE_READY)
+  {
+    DEBUG_PRINT("[E] CAN2 error code: 0x%08lX\r\n", (unsigned long)HAL_CAN_GetError(&hcan2));
+  }
+
+  // TODO: write error to SD
+
+  /* Disabling interrupts here (after reporting above) freezes the FreeRTOS
+     scheduler for good, since it relies on SysTick/PendSV. */
   __disable_irq();
 
-  //TODO: check if it is necessary to stop FreeRTOS
-
-  uint32_t error_code_can1;
-  uint32_t error_code_can2;
-
-  if (HAL_CAN_GetState(&hcan1) != HAL_CAN_STATE_READY) error_code_can1 = HAL_CAN_GetError(&hcan1);
-  if (HAL_CAN_GetState(&hcan2) != HAL_CAN_STATE_READY) error_code_can2 = HAL_CAN_GetError(&hcan2);
-
-  // TODO: write error to SD and/or serial
-
   HAL_GPIO_WritePin(led_can1.port, led_can1.pin, GPIO_PIN_RESET);
   HAL_GPIO_WritePin(led_can2.port, led_can2.pin, GPIO_PIN_RESET);
 
   while (1)
   {
       HAL_GPIO_TogglePin(led_error.port, led_error.pin);
-    HAL_Delay(250);
+      for(volatile uint32_t i = 0; i < 4000000; i++);
   }
   /* USER CODE END Error_Handler_Debug */
 }

Core/Src/stm32f4xx_it.c

@@ -41,7 +41,8 @@
 
 /* Private variables ---------------------------------------------------------*/
 /* USER CODE BEGIN PV */
-
+extern CAN_HandleTypeDef hcan1;
+extern CAN_HandleTypeDef hcan2;
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -250,4 +251,20 @@ void DMA2_Stream7_IRQHandler(void)
 
 /* USER CODE BEGIN 1 */
 
+/**
+  * @brief This function handles CAN1 RX0 interrupt.
+  */
+void CAN1_RX0_IRQHandler(void)
+{
+  HAL_CAN_IRQHandler(&hcan1);
+}
+
+/**
+  * @brief This function handles CAN2 RX0 interrupt.
+  */
+void CAN2_RX0_IRQHandler(void)
+{
+  HAL_CAN_IRQHandler(&hcan2);
+}
+
 /* USER CODE END 1 */