c - STM32 cube and CAN-bus - Stack Overflow

admin管理员组

文章数量:1287584

I am working on an STM32 microcontroller project that involves CAN (Controller Area Network) communication and UART. My setup includes the following:

CAN Configuration: The CAN peripheral is initialized in Loopback Mode for testing. The TxHeader is set with standard identifier (StdId = 0x103), data frame mode (CAN_RTR_DATA), and an 8-byte payload. The message is transmitted using HAL_CAN_AddTxMessage().

Receiving CAN Messages: I have enabled CAN reception with HAL_CAN_ActivateNotification(). The HAL_CAN_RxFifo0MsgPendingCallback() function is implemented to retrieve incoming messages.

Issue: The TxData array is correctly populated with data, but it appears that the transmitted message is not being received as expected. The RxData buffer remains zero (0x00 for all bytes), indicating that no data is received. I am using Loopback Mode, so I expect the transmitted message to be received by the same device. Why this happens?

/* USER CODE BEGIN Header */
/**
#include "main.h"
#include "string.h"
#include <stdio.h>

CAN_HandleTypeDef hcan;

UART_HandleTypeDef huart2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN_Init(void);
static void MX_USART2_UART_Init(void);

CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;

uint32_t TxMailbox;

uint8_t TxData [8];
uint8_t RxData [8];

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan){
HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData);
  }

int main(void)
 {

HAL_Init();

SystemClock_Config();

MX_GPIO_Init();
MX_CAN_Init();
MX_USART2_UART_Init();


HAL_CAN_Start(&hcan); 
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING); 
TxHeader.DLC = 8; 
TxHeader.ExtId = 0;  
TxHeader.IDE = CAN_ID_STD; 
TxHeader.RTR =CAN_RTR_DATA; 
TxHeader.StdId = 0x103;  τη CAN device
TxHeader.TransmitGlobalTime = DISABLE; 

memset(TxData, 0, sizeof(TxData));
TxData[0] =0xf3 ;

HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox);

while (1)
{
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}


void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
   Error_Handler();
  }

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                          |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
 {
  Error_Handler();
 }
}

static void MX_CAN_Init(void)
{

hcan.Instance = CAN1;
hcan.Init.Prescaler = 18;
hcan.Init.Mode = CAN_MODE_LOOPBACK;
hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan.Init.TimeSeg1 = CAN_BS1_2TQ;
hcan.Init.TimeSeg2 = CAN_BS2_1TQ;
hcan.Init.TimeTriggeredMode = DISABLE;
hcan.Init.AutoBusOff = DISABLE;
hcan.Init.AutoWakeUp = DISABLE;
hcan.Init.AutoRetransmission = DISABLE;
hcan.Init.ReceiveFifoLocked = DISABLE;
hcan.Init.TransmitFifoPriority = DISABLE;
if (HAL_CAN_Init(&hcan) != HAL_OK)
{
Error_Handler();
 }
/* USER CODE BEGIN CAN_Init 2 */


CAN_FilterTypeDef canfilterconfig;
canfilterconfig.FilterActivation = CAN_FILTER_ENABLE;
canfilterconfig.FilterBank =10;
canfilterconfig.FilterFIFOAssignment = CAN_RX_FIFO0;
canfilterconfig.FilterIdHigh =0;
canfilterconfig.FilterIdLow = 0x0000;
canfilterconfig.FilterMaskIdHigh =0;
canfilterconfig.FilterMaskIdLow = 0x0000;
canfilterconfig.FilterMode = CAN_FILTERMODE_IDMASK;
canfilterconfig.FilterScale = CAN_FILTERSCALE_32BIT;

HAL_CAN_ConfigFilter( &hcan, &canfilterconfig);

canfilterconfig.SlaveStartFilterBank = 0;
 /* USER CODE END CAN_Init 2 */

 }
static void MX_USART2_UART_Init(void)
 {

huart2.Instance = USART2;
 huart2.Init.BaudRate = 115200;
huart2.Init.WordLength = UART_WORDLENGTH_8B;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = UART_PARITY_NONE;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart2) != HAL_OK)
{
 Error_Handler();
 }

 }

static void MX_GPIO_Init(void)
 {

 __HAL_RCC_GPIOD_CLK_ENABLE();
   __HAL_RCC_GPIOA_CLK_ENABLE();

 }
     void Error_Handler(void)
{

  __disable_irq();
  while (1)
 {
 }

  }

  #ifdef  USE_FULL_ASSERT

 void assert_failed(uint8_t *file, uint32_t line)
{

}
 #endif /* USE_FULL_ASSERT *`

本文标签： cSTM32 cube and CANbusStack Overflow