Cant get CAN bus working

[CEnge.1]

I am trying to get CAN working on the stm32f0discovery. I have hooked up a transceiver on PB8 and PB9. I have written some basic code with the STM32Cube help. But I cant get transmitting or receiving working. I have probed the pins and I can see that there are messages being received on the RX pin (PB8). I cant see anything on PB9 so I am sure it is not the transceiver.

Please look over my code and see what I am missing.

Here is my main.c:

#include "main.h"
 
 
CAN_HandleTypeDef hcan;
CAN_FilterTypeDef filter;
 
 
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN_Init(void);
void CAN_Tx(void);
 
void CAN_Tx(void){
 
	CAN_TxHeaderTypeDef TxHeader;
 
	uint8_t msg[8] = {'M','E','S', 'S', 'A', 'G', 'E'};
	uint32_t TxMailBox;
 
	TxHeader.DLC= 7;
	TxHeader.StdId=0x65D;
	TxHeader.IDE= CAN_ID_STD;
	TxHeader.RTR= CAN_RTR_DATA;
 
	if(HAL_CAN_AddTxMessage(&hcan, &TxHeader, msg , &TxMailBox)!= HAL_OK)
	{
		Error_Handler();
	}
 
 
	while(HAL_CAN_IsTxMessagePending(&hcan, TxMailBox));
}
 
 
int main(void)
{
 /* USER CODE BEGIN 1 */
 
 /* USER CODE END 1 */
 
 /* MCU Configuration--------------------------------------------------------*/
 
 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();
 
 /* USER CODE BEGIN Init */
 
 /* USER CODE END Init */
 
 /* Configure the system clock */
 SystemClock_Config();
 
 /* USER CODE BEGIN SysInit */
 
 /* USER CODE END SysInit */
 
 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_CAN_Init();
 /* USER CODE BEGIN 2 */
 HAL_CAN_Start(&hcan);
 /* USER CODE END 2 */
 
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */
 
 /* USER CODE BEGIN 3 */
	 //CAN_Tx();
	 if(HAL_CAN_GetRxFifoFillLevel(&hcan, CAN_RX_FIFO0)){
		 CAN_RxHeaderTypeDef rx_msg;
		 uint8_t aData[8];
		 HAL_CAN_GetRxMessage(&hcan, CAN_RX_FIFO0, &rx_msg, aData);
	 }
 }
 /* USER CODE END 3 */
}
 
/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
 /** Initializes the CPU, AHB and APB busses clocks 
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48;
 RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 /** Initializes the CPU, AHB and APB busses clocks 
 */
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
 |RCC_CLOCKTYPE_PCLK1;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI48;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
 
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
 {
 Error_Handler();
 }
 
 HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
 HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
 HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}
 
/**
 * @brief CAN Initialization Function
 * @param None
 * @retval None
 */
static void MX_CAN_Init(void)
{
 
 /* USER CODE BEGIN CAN_Init 0 */
 
 /* USER CODE END CAN_Init 0 */
 
 /* USER CODE BEGIN CAN_Init 1 */
 
 /* USER CODE END CAN_Init 1 */
 hcan.Instance = CAN;
 hcan.State = HAL_CAN_STATE_RESET;
 hcan.Init.Prescaler = 16;
 hcan.Init.Mode = CAN_MODE_NORMAL;
 hcan.Init.SyncJumpWidth = CAN_SJW_2TQ;
 hcan.Init.TimeSeg1 = CAN_BS1_4TQ;
 hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
 hcan.Init.TimeTriggeredMode = DISABLE;
 hcan.Init.AutoBusOff = DISABLE;
 hcan.Init.AutoWakeUp = DISABLE;
 hcan.Init.AutoRetransmission = ENABLE;
 hcan.Init.ReceiveFifoLocked = DISABLE;
 hcan.Init.TransmitFifoPriority = DISABLE;
 if (HAL_CAN_Init(&hcan) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN CAN_Init 2 */
 filter.FilterIdHigh = 0;
 filter.FilterIdLow = 0;
 filter.FilterMaskIdHigh = 0;
 filter.FilterMaskIdLow = 0;
 filter.FilterMode = CAN_FILTERMODE_IDMASK;
 filter.FilterScale = CAN_FILTERSCALE_32BIT;
 filter.FilterBank = 0;
 filter.FilterFIFOAssignment = CAN_RX_FIFO0;
 filter.FilterActivation = ENABLE;
 HAL_CAN_ConfigFilter(&hcan, &filter);
 /* USER CODE END CAN_Init 2 */
 
}
 
/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 
 /* GPIO Ports Clock Enable */
 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 
 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOC, NCS_MEMS_SPI_Pin|EXT_RESET_Pin|LD3_Pin|LD6_Pin 
 |LD4_Pin|LD5_Pin, GPIO_PIN_RESET);
 
 /*Configure GPIO pins : NCS_MEMS_SPI_Pin EXT_RESET_Pin LD3_Pin LD6_Pin 
 LD4_Pin LD5_Pin */
 GPIO_InitStruct.Pin = NCS_MEMS_SPI_Pin|EXT_RESET_Pin|LD3_Pin|LD6_Pin 
 |LD4_Pin|LD5_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
 /*Configure GPIO pins : MEMS_INT1_Pin MEMS_INT2_Pin */
 GPIO_InitStruct.Pin = MEMS_INT1_Pin|MEMS_INT2_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_EVT_RISING;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
 /*Configure GPIO pin : B1_Pin */
 GPIO_InitStruct.Pin = B1_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_EVT_RISING;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);
 
 /*Configure GPIO pins : PA2 PA3 PA6 PA7 */
 GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_6|GPIO_PIN_7;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF3_TSC;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
 /*Configure GPIO pins : PB0 PB1 */
 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 GPIO_InitStruct.Alternate = GPIO_AF3_TSC;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
 /*Configure GPIO pins : I2C2_SCL_Pin I2C2_SDA_Pin */
 GPIO_InitStruct.Pin = I2C2_SCL_Pin|I2C2_SDA_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
 GPIO_InitStruct.Pull = GPIO_PULLUP;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF1_I2C2;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
 /*Configure GPIO pins : SPI2_SCK_Pin SPI2_MISO_Pin SPI2_MOSI_Pin */
 GPIO_InitStruct.Pin = SPI2_SCK_Pin|SPI2_MISO_Pin|SPI2_MOSI_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
}
 
/* USER CODE BEGIN 4 */
 
/* USER CODE END 4 */
 
/**
 * @brief This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
 /* USER CODE BEGIN Error_Handler_Debug */
 /* User can add his own implementation to report the HAL error return state */
 
 /* USER CODE END Error_Handler_Debug */
}
 
#ifdef USE_FULL_ASSERT
/**
 * @brief Reports the name of the source file and the source line number
 * where the assert_param error has occurred.
 * @param file: pointer to the source file name
 * @param line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line)
{ 
 /* USER CODE BEGIN 6 */
 /* User can add his own implementation to report the file name and line number,
 tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
 /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

and my stm32f0xx_hal_msp.c

void HAL_MspInit(void)
{
 /* USER CODE BEGIN MspInit 0 */
 
 /* USER CODE END MspInit 0 */
 
 __HAL_RCC_SYSCFG_CLK_ENABLE();
 __HAL_RCC_PWR_CLK_ENABLE();
 
 /* System interrupt init*/
 HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
 
 /* USER CODE BEGIN MspInit 1 */
 
 /* USER CODE END MspInit 1 */
}
 
/**
* @brief CAN MSP Initialization
* This function configures the hardware resources used in this example
* @param hcan: CAN handle pointer
* @retval None
*/
void HAL_CAN_MspInit(CAN_HandleTypeDef* hcan)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 if(hcan->Instance==CAN)
 {
 /* USER CODE BEGIN CAN_MspInit 0 */
 
 /* USER CODE END CAN_MspInit 0 */
 /* Peripheral clock enable */
 __HAL_RCC_CAN1_CLK_ENABLE();
 
 __HAL_RCC_GPIOB_CLK_ENABLE();
 /**CAN GPIO Configuration 
 PB8 ------> CAN_RX
 PB9 ------> CAN_TX 
 */
 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_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF4_CAN;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
 /* USER CODE BEGIN CAN_MspInit 1 */
 
 /* USER CODE END CAN_MspInit 1 */
 }
 
}

[Jack Peacock_2]

You didn't mention how the other node is configured. Make sure both nodes are configured for the same bit timing, you are using twisted-pair wiring between nodes with about 50cm minimum distance, and that both ends of the cable are terminated.

CAN will not work unless at least two nodes configured for same data rate and timing are present. Check the status registers on both nodes to see what error is present.

Jack Peacock

[YS.K]

The code above is similar to my code.

​

I'm also working on the STM32CubeMX FW_L4 v1.5.1 library on the Nucleo-L476RG board,

and there is a similar phenomenon that doesn't work like you,

so please let me know when the problem is solved.

​

If you want to use CAN RX interrupt, add the code below.​

HAL_CAN_Start(&hcan);

HAL_CAN_ActivateNotification(&hcan,

 CAN_IT_ERROR|CAN_IT_LAST_ERROR_CODE|CAN_IT_BUSOFF|CAN_IT_ERROR_PASSIVE|CAN_IT_ERROR_WARNING|

 CAN_IT_RX_FIFO0_MSG_PENDING|CAN_IT_RX_FIFO1_MSG_PENDING|

 CAN_IT_RX_FIFO0_OVERRUN|CAN_IT_RX_FIFO0_FULL|CAN_IT_RX_FIFO0_MSG_PENDING|

 CAN_IT_TX_MAILBOX_EMPTY);

​

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *phcan)

{

if (phcan->Instance == CAN1) {

HAL_CAN_GetRxMessage(phcan, CAN_RX_FIFO0, &rxHeader, &rxData[0]);

// HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);//LED

}

}