Put message on CAN1 queue to test all stack

Core/Inc/cansend.h

@@ -22,7 +22,6 @@
 
 #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,15 +45,18 @@ extern "C" {
 
 /* Exported macro ------------------------------------------------------------*/
 /* USER CODE BEGIN EM */
-//#define DEBUG_ITM
-#define DEBUG_DUMMY_FRAME
+//#define DEBUG_ITW
+//#define DEBUG_DUMMY_FRAME
 
-#ifdef DEBUG_ITM
+#ifdef DEBUG_ITW
 #include <stdio.h>
 #define DEBUG_PRINT(...) printf(__VA_ARGS__)
 #else
-#define DEBUG_PRINT(...) uart_printf(__VA_ARGS__)
+#include <stdarg.h>
+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,7 +18,6 @@
 #include "main.h"
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
-#include "cansend.h"
 #include "cmsis_os.h"
 #include <string.h>
 /* USER CODE END Includes */
@@ -29,6 +28,9 @@ 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 */
 /**
@@ -39,22 +41,21 @@ extern osThreadId_t xCAN2LedTask;
   */
 void CAN_Logger_Init(CAN_HandleTypeDef *hcan1, CAN_HandleTypeDef *hcan2)
 {
-    CAN_FilterTypeDef filter = {0};
-    filter.FilterMode = CAN_FILTERMODE_IDMASK;
-    filter.FilterScale = CAN_FILTERSCALE_32BIT;
-    filter.FilterIdHigh = 0x0000;
-    filter.FilterMaskIdHigh = 0x0000;
-    filter.FilterIdLow = 0x0000;
-    filter.FilterMaskIdLow = 0x0000;
-    filter.FilterFIFOAssignment = CAN_FILTER_FIFO0;
-    filter.FilterActivation = ENABLE;
-    filter.SlaveStartFilterBank = 14;
+  CAN_FilterTypeDef filter = {0};
+  filter.FilterMode = CAN_FILTERMODE_IDMASK;
+  filter.FilterScale = CAN_FILTERSCALE_32BIT;
+  filter.FilterIdHigh = 0x0000;
+  filter.FilterMaskIdHigh = 0x0000;
+  filter.FilterIdLow = 0x0000;
+  filter.FilterMaskIdLow = 0x0000;
+  filter.FilterFIFOAssignment = CAN_FILTER_FIFO0;
+  filter.FilterActivation = ENABLE;
+  filter.SlaveStartFilterBank = 14;
 
-    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();
+  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();
 }
 /* END CAN_Logger_Init */
 
@@ -66,35 +67,38 @@ void CAN_Logger_Init(CAN_HandleTypeDef *hcan1, CAN_HandleTypeDef *hcan2)
   */
 void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
 {
-    CanMessage_t message;
-    CAN_RxHeaderTypeDef rxHeader;
-    uint8_t data[8];
+  if (hcan->Instance == CAN1) can1_rx_isr_count++;
+  else can2_rx_isr_count++;
 
-    osMessageQueueId_t queue;
-    osThreadId_t led_task;
+  CanMessage_t message;
+  CAN_RxHeaderTypeDef rxHeader;
+  uint8_t data[8];
 
-    // TODO: manage the case of FIFO overflow
-    if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &rxHeader, data) != HAL_OK) return;
+  osMessageQueueId_t queue;
+  osThreadId_t led_task;
 
-    if (rxHeader.IDE == CAN_ID_EXT) message.id = rxHeader.ExtId;
-    else message.id = rxHeader.StdId;
-    message.dlc = rxHeader.DLC;
-    message.isExtended = (rxHeader.IDE == CAN_ID_EXT);
-    message.source = (hcan->Instance == CAN1) ? 1 : 2;
-    memcpy(message.payload, data, rxHeader.DLC);
+  // TODO: manage the case of FIFO overflow
+  if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &rxHeader, data) != HAL_OK) return;
 
-    if (hcan->Instance == CAN1)
-    {
-        queue    = xCAN1RxQueue;
-        led_task = xCAN1LedTask;
-    }
-    else
-    {
-        queue    = xCAN2RxQueue;
-        led_task = xCAN2LedTask;
-    }
+  if (rxHeader.IDE == CAN_ID_EXT) message.id = rxHeader.ExtId;
+  else message.id = rxHeader.StdId;
+  message.dlc = rxHeader.DLC;
+  message.isExtended = (rxHeader.IDE == CAN_ID_EXT);
+  message.source = (hcan->Instance == CAN1) ? 1 : 2;
+  memcpy(message.payload, data, rxHeader.DLC);
 
-    if (osMessageQueuePut(queue, &message, 0U, 0U) == osOK) osThreadFlagsSet(led_task, 0x01);
+  if (hcan->Instance == CAN1)
+  {
+    queue    = xCAN1RxQueue;
+    led_task = xCAN1LedTask;
+  }
+  else
+  {
+    queue    = xCAN2RxQueue;
+    led_task = xCAN2LedTask;
+  }
+
+  if (osMessageQueuePut(queue, &message, 0U, 0U) == osOK) osThreadFlagsSet(led_task, 0x01);
 }
 /* END HAL_CAN_RxFifo0MsgPendingCallback */
 
@@ -114,7 +118,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, 5, 0);
+  HAL_NVIC_SetPriority(irqn, 6, 0);
   HAL_NVIC_EnableIRQ(irqn);
 
   for (;;)
@@ -125,13 +129,14 @@ void vCANListener(void *argument)
 
       osMessageQueuePut(xUARTQueue, &message, 0U, 0U);
     }
+    else DEBUG_PRINT("No CAN yet!\r\n");
   }
 }
 /* END vCANListener */
 
 /* BEGIN vLEDHeartbeat */
 /**
-  * @brief  Turn on LED when CAN traffic is detected
+  * @brief  Blink a LED in heartbeat mode when CAN traffic is detected
   * @param  argument: LED GPIO (port and pin)
   * @retval None
   */

Core/Src/cansend.c

@@ -22,47 +22,15 @@
 #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 UART_HandleTypeDef huart1;
-extern osSemaphoreId_t xUARTDMASemaphore;
-
-/* 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 */
+extern volatile uint32_t can1_rx_isr_count;
+extern volatile uint32_t can2_rx_isr_count;
+extern CAN_HandleTypeDef hcan1;
+extern CAN_HandleTypeDef hcan2;
 
 /* BEGIN format_can_message */
 /**
@@ -128,31 +96,7 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 }
 /* END HAL_UART_TxCpltCallback */
 
-/* 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 */
+/* BEGIN vUARTLoggerListen */
 /**
   * @brief  Send CAN bus traffic saved in FIFO buffer to USART1
   * @param  argument: Not used
@@ -161,7 +105,9 @@ void HAL_UART_ErrorCallback(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 = {
@@ -175,21 +121,64 @@ void vUARTLogger(void *argument)
 
   for (;;)
   {
-    if (osMessageQueueGet(xUARTQueue, &message, NULL, 1000U) == osOK)
+    uint32_t queue_timeout = 1000U;
+
+    //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 (osSemaphoreAcquire(xUARTDMASemaphore, 100U) == osOK)
+      if (huart1.gState != HAL_UART_STATE_READY)
+      {
+        HAL_UART_Abort(&huart1);
+        HAL_UART_Init(&huart1);
+      }
+
+      if (osSemaphoreAcquire(xUARTDMASemaphore, queue_timeout) == osOK)
       {
         int len = format_can_message(tx_buffer, message.source, &message);
-
         if (HAL_UART_Transmit_DMA(&huart1, (uint8_t*)tx_buffer, len) != HAL_OK)
         {
           osSemaphoreRelease(xUARTDMASemaphore);
-          DEBUG_PRINT("[E] HAL error, CAN frame NOT sent!\r\n");
+          DEBUG_PRINT("HAL error, CAN frame NOT sent!\r\n");
         }
       }
-      else DEBUG_PRINT("[E] Semaphore timeout! UART might be stuck in BUSY state.\r\n");
-	}
-   	else DEBUG_PRINT("[D] Waiting for CAN traffic...\r\n");
+      else
+      {
+        DEBUG_PRINT("ERROR: Semaphore timeout! UART might be stuck in BUSY state.\r\n");
+        HAL_UART_Abort(&huart1);
+        HAL_UART_Init(&huart1);
+        osSemaphoreRelease(xUARTDMASemaphore);
+      }
+    }
+    else
+    {
+      if (osSemaphoreAcquire(xUARTDMASemaphore, queue_timeout) == osOK)
+      {
+        int len = snprintf(diag_buf, sizeof(diag_buf),
+        "[D] ISR1:%lu ISR2:%lu | ST1:%lu ST2:%lu | ER1:0x%lX ER2:0x%lX\r\n",
+        (unsigned long)can1_rx_isr_count, (unsigned long)can2_rx_isr_count,
+        (unsigned long)HAL_CAN_GetState(&hcan1), (unsigned long)HAL_CAN_GetState(&hcan2),
+        (unsigned long)HAL_CAN_GetError(&hcan1), (unsigned long)HAL_CAN_GetError(&hcan2));
+
+        if (len > 0)
+        {
+          if (HAL_UART_Transmit_DMA(&huart1, (uint8_t*)diag_buf, len) != HAL_OK) osSemaphoreRelease(xUARTDMASemaphore);
+        }
+        else osSemaphoreRelease(xUARTDMASemaphore);
+      }
+      else
+      {
+        HAL_UART_Abort(&huart1);
+        HAL_UART_Init(&huart1);
+        osSemaphoreRelease(xUARTDMASemaphore);
+        DEBUG_PRINT("ERROR: Semaphore timeout! UART might be stuck in BUSY state.\r\n");
+      }
+    }
   }
 }
-/* END vUARTLogger */
+/* END vUARTLoggerListen */

Core/Src/main.c

@@ -21,6 +21,8 @@
 /* USER CODE BEGIN Includes */
 #include "canlog.h"
 #include "cansend.h"
+#include <stdio.h>
+#include <stdarg.h>
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -64,7 +66,6 @@ osMessageQueueId_t xUARTQueue;
 
 osSemaphoreId_t xUARTDMASemaphore;
 osThreadId_t xUartTask;
-
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -75,16 +76,33 @@ 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 */
 
-void uart_printf(const char *fmt, ...);
-
-/* USER CODE BEGIN PFP */
+/* USER CODE BEGIN PF */
 int _write(int file, char *ptr, int len)
 {
   for (int i = 0; i < len; i++) ITM_SendChar((*ptr++));
   return len;
 }
-/* USER CODE END PFP */
+
+#ifndef DEBUG_ITM
+void uart_debug_print(const char *fmt, ...)
+{
+  char buf[128];
+  va_list args;
+
+  va_start(args, fmt);
+  int len = vsnprintf(buf, sizeof(buf), fmt, args);
+  va_end(args);
+
+  if (len > 0)
+  {
+    while (HAL_UART_GetState(&huart1) & HAL_UART_STATE_BUSY_TX);
+    HAL_UART_Transmit(&huart1, (uint8_t*)buf, len, 100);
+  }
+}
+#endif
+/* USER CODE END PF */
 
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
@@ -106,7 +124,7 @@ int main(void)
     ITM->TCR = ITM_TCR_ITMENA_Msk | ITM_TCR_SYNCENA_Msk | ITM_TCR_SWOENA_Msk;
   }
 
-  DEBUG_PRINT("[L] Booting system\r\n");
+  DEBUG_PRINT("Booting system\r\n");
   /* USER CODE END 1 */
 
   /* MCU Configuration--------------------------------------------------------*/
@@ -115,7 +133,7 @@ int main(void)
   HAL_Init();
 
   /* USER CODE BEGIN Init */
-  DEBUG_PRINT("[L] Configuring system clock\r\n");
+  DEBUG_PRINT("Configuring system clock\r\n");
 
   /* USER CODE END Init */
 
@@ -123,25 +141,25 @@ int main(void)
   SystemClock_Config();
 
   /* USER CODE BEGIN SysInit */
-  DEBUG_PRINT("[L] Initializing configured peripherals...\r\n");
+  DEBUG_PRINT("Initializing configured peripherals...\r\n");
   /* USER CODE END SysInit */
 
   /* Initialize all configured peripherals */
-  MX_DMA_Init();
   MX_GPIO_Init();
-  MX_USART1_UART_Init();
+  MX_DMA_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");
+  DEBUG_PRINT("Initializing CAN bus logger\r\n");
   CAN_Logger_Init(&hcan1, &hcan2);
   /* USER CODE END 2 */
 
   /* Init scheduler */
   osKernelInitialize();
 
-  DEBUG_PRINT("[L] Creating RTOS entities\r\n");
+  DEBUG_PRINT("Creating RTOS entities\r\n");
 
   /* USER CODE BEGIN RTOS_TASKS */
   const osThreadAttr_t CAN1rxAttributes = {
@@ -202,7 +220,7 @@ int main(void)
   /* USER CODE END RTOS_EVENTS */
 
   /* Start scheduler */
-  DEBUG_PRINT("[L] Starting RTOS init scheduler\r\n");
+  DEBUG_PRINT("Starting RTOS init scheduler\r\n");
   osKernelStart();
 
   /* We should never get here as control is now taken by the scheduler */
@@ -214,7 +232,7 @@ int main(void)
     /* USER CODE END WHILE */
 
     /* USER CODE BEGIN 3 */
-    DEBUG_PRINT("[E] RTOS scheduler crashed!\r\n");
+    DEBUG_PRINT("ERROR: RTOS scheduler crashed!\r\n");
     /* USER CODE END 3 */
   }
 }
@@ -297,7 +315,7 @@ static void MX_CAN1_Init(void)
     Error_Handler();
   }
   /* USER CODE BEGIN CAN1_Init 2 */
-  DEBUG_PRINT("[L] CAN1 initialized\r\n");
+  DEBUG_PRINT("CAN1 initialized!\r\n");
   /* USER CODE END CAN1_Init 2 */
 
 }
@@ -334,7 +352,7 @@ static void MX_CAN2_Init(void)
     Error_Handler();
   }
   /* USER CODE BEGIN CAN2_Init 2 */
-  DEBUG_PRINT("[L] CAN2 initialized\r\n");
+  DEBUG_PRINT("CAN2 initialized!\r\n");
   /* USER CODE END CAN2_Init 2 */
 
 }
@@ -370,7 +388,7 @@ static void MX_SDIO_SD_Init(void)
   //  Error_Handler();
   //}
   /* USER CODE BEGIN SDIO_Init 2 */
-  //DEBUG_PRINT("[L] SDIO initialized\r\n");
+  //DEBUG_PRINT("SDIO initialized!\r\n");
   /* USER CODE END SDIO_Init 2 */
 
 }
@@ -395,7 +413,7 @@ static void MX_USART1_UART_Init(void)
   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   huart1.Init.StopBits = UART_STOPBITS_1;
   huart1.Init.Parity = UART_PARITY_NONE;
-  huart1.Init.Mode = UART_MODE_TX;
+  huart1.Init.Mode = UART_MODE_TX_RX;
   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
   if (HAL_UART_Init(&huart1) != HAL_OK)
@@ -403,7 +421,7 @@ static void MX_USART1_UART_Init(void)
     Error_Handler();
   }
   /* USER CODE BEGIN USART1_Init 2 */
-  DEBUG_PRINT("[L] USART1 initialized\r\n");
+  DEBUG_PRINT("USART1 initialized!\r\n");
   /* USER CODE END USART1_Init 2 */
 
 }
@@ -429,7 +447,7 @@ static void MX_DMA_Init(void)
   HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
 
   /* USER CODE BEGIN MX_DMA_Init 1 */
-  DEBUG_PRINT("[L] DMA initialized\r\n");
+  DEBUG_PRINT("DMA initialized!\r\n");
   /* USER CODE END MX_DMA_Init 1 */
 }
 
@@ -498,24 +516,8 @@ 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");
+  DEBUG_PRINT("GPIO initialized!\r\n");
   /* USER CODE END MX_GPIO_Init_2 */
 }
 
@@ -550,7 +552,7 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   */
 void Error_Handler(void)
 {
-  DEBUG_PRINT("[E] Entering error handler\r\n");
+  DEBUG_PRINT("ERROR: entering error handler\r\n");
 
   /* USER CODE BEGIN Error_Handler_Debug */
   /* User can add his own implementation to report the HAL error return state */
@@ -571,8 +573,8 @@ void Error_Handler(void)
 
   while (1)
   {
-      HAL_GPIO_TogglePin(led_error.port, led_error.pin);
-      for(volatile uint32_t i = 0; i < 4000000; i++);
+    HAL_GPIO_TogglePin(led_error.port, led_error.pin);
+    HAL_Delay(250);
   }
   /* USER CODE END Error_Handler_Debug */
 }

Core/Src/stm32f4xx_it.c

@@ -41,8 +41,7 @@
 
 /* Private variables ---------------------------------------------------------*/
 /* USER CODE BEGIN PV */
-extern CAN_HandleTypeDef hcan1;
-extern CAN_HandleTypeDef hcan2;
+
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -251,20 +250,4 @@ 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 */