CAN TX

[Ash1]

Hi all

Can You provide me a correct code for how we can transfer TX frame using HAL .

please check my code below .

Issue what I am facing in my code is only I am seeing first ID data even data and ID are correctly stored inside buffer.

Please guide me .

PFA

[Ash1]

Hi 

As I am unable to attached all images. I am replying on same post.

B.R

Ashish

[Peter BENSCH]

It's a bad idea to insert code as screenshots, partly because you can't search images for text.

There are therefore instructions in the Community Guidelines on how to insert code, for which there is an explicit function field </>, which you have also used in previous posts. Please remove the images and replace them with the code block.

Thank you
/Peter

[mƎALLEm]

Hello,

Your description is not clear. See: https://community.st.com/t5/community-guidelines/how-to-write-your-question-to-maximize-your-chances-to-find-a/ta-p/575228

Also instead of attaching screenshots of your code, please use </> button to paste it here.

See: https://community.st.com/t5/community-guidelines/how-to-insert-source-code/ta-p/693413

[Ash1]

Hi 

I am editing in the same post 

Please check code. I am getting HAL_OK every time but unable to see TI1R data on the BUS.ONLY TI0R data I can see. even transmit mail box value getting change alternative 0 to 1 still facing the issue

	while (1)
	{


		// Example: Transmit a CAN message
		CAN_TxHeaderTypeDef txHeader;
	 	const uint8_t tx_data[8] = {0x11};
		const uint8_t tx_data1[8] = {0x12};
		uint32_t tx_mailbox_used;

		txHeader.StdId = 0x3e8; // Example CAN ID
		txHeader.RTR = CAN_RTR_DATA;
		txHeader.IDE = CAN_ID_STD;
		txHeader.DLC = 8;

		if (HAL_CAN_AddTxMessage(&hcan1, &txHeader, tx_data, &tx_mailbox_used) != HAL_OK)
		{
			Error_Handler();
		}

		txHeader.StdId = 0x244; // Example CAN ID
				txHeader.RTR = CAN_RTR_DATA;
				txHeader.IDE = CAN_ID_STD;
				txHeader.DLC = 8;

		if (HAL_CAN_AddTxMessage(&hcan1, &txHeader, tx_data1, &tx_mailbox_used) != HAL_OK)
				{
					Error_Handler();
				}

		HAL_Delay(10);


	}







HAL_StatusTypeDef HAL_CAN_AddTxMessage(CAN_HandleTypeDef *hcan, const CAN_TxHeaderTypeDef *pHeader,
 const uint8_t aData[], uint32_t *pTxMailbox)
{
 uint32_t transmitmailbox;
 HAL_CAN_StateTypeDef state = hcan->State;
 uint32_t tsr = READ_REG(hcan->Instance->TSR);

 /* Check the parameters */
 assert_param(IS_CAN_IDTYPE(pHeader->IDE));
 assert_param(IS_CAN_RTR(pHeader->RTR));
 assert_param(IS_CAN_DLC(pHeader->DLC));
 if (pHeader->IDE == CAN_ID_STD)
 {
 assert_param(IS_CAN_STDID(pHeader->StdId));
 }
 else
 {
 assert_param(IS_CAN_EXTID(pHeader->ExtId));
 }
 assert_param(IS_FUNCTIONAL_STATE(pHeader->TransmitGlobalTime));

 if ((state == HAL_CAN_STATE_READY) ||
 (state == HAL_CAN_STATE_LISTENING))
 {
 /* Check that all the Tx mailboxes are not full */
 if (((tsr & CAN_TSR_TME0) != 0U) ||
 ((tsr & CAN_TSR_TME1) != 0U) ||
 ((tsr & CAN_TSR_TME2) != 0U))
 {
 /* Select an empty transmit mailbox */
 transmitmailbox = (tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos;

 /* Store the Tx mailbox */
 *pTxMailbox = (uint32_t)1 << transmitmailbox;

 /* Set up the Id */
 if (pHeader->IDE == CAN_ID_STD)
 {
 hcan->Instance->sTxMailBox[transmitmailbox].TIR = ((pHeader->StdId << CAN_TI0R_STID_Pos) |
 pHeader->RTR);
 }
 else
 {
 hcan->Instance->sTxMailBox[transmitmailbox].TIR = ((pHeader->ExtId << CAN_TI0R_EXID_Pos) |
 pHeader->IDE |
 pHeader->RTR);
 }

 /* Set up the DLC */
 hcan->Instance->sTxMailBox[transmitmailbox].TDTR = (pHeader->DLC);

 /* Set up the Transmit Global Time mode */
 if (pHeader->TransmitGlobalTime == ENABLE)
 {
 SET_BIT(hcan->Instance->sTxMailBox[transmitmailbox].TDTR, CAN_TDT0R_TGT);
 }

 /* Set up the data field */
 WRITE_REG(hcan->Instance->sTxMailBox[transmitmailbox].TDHR,
 ((uint32_t)aData[7] << CAN_TDH0R_DATA7_Pos) |
 ((uint32_t)aData[6] << CAN_TDH0R_DATA6_Pos) |
 ((uint32_t)aData[5] << CAN_TDH0R_DATA5_Pos) |
 ((uint32_t)aData[4] << CAN_TDH0R_DATA4_Pos));
 WRITE_REG(hcan->Instance->sTxMailBox[transmitmailbox].TDLR,
 ((uint32_t)aData[3] << CAN_TDL0R_DATA3_Pos) |
 ((uint32_t)aData[2] << CAN_TDL0R_DATA2_Pos) |
 ((uint32_t)aData[1] << CAN_TDL0R_DATA1_Pos) |
 ((uint32_t)aData[0] << CAN_TDL0R_DATA0_Pos));

 /* Request transmission */
 SET_BIT(hcan->Instance->sTxMailBox[transmitmailbox].TIR, CAN_TI0R_TXRQ);



 /* Return function status */
 return HAL_OK;
 }
 else
 {
 /* Update error code */
 hcan->ErrorCode |= HAL_CAN_ERROR_PARAM;

 return HAL_ERROR;
 }
 }
 else
 {
 /* Update error code */
 hcan->ErrorCode |= HAL_CAN_ERROR_NOT_INITIALIZED;

 return HAL_ERROR;
 }
}

  

[mƎALLEm]

1- Please give more details about your HW. You are not even giving the MCU part number? the board? Which transceiver?

2- Are you using Normal or Loopback mode. Better to attach your project.

3- Your description still not clear. Which ID is not sent on the bus?

[mƎALLEm]

In case you face an issue with the Loopack mode: Troubleshooting bxCAN issues in Loop Back mode on STM32 MCUs 

[Ash1]

Hi

How Can I attach project in reply

[Ash1]

Hi all

Please check my code is it correct way for loopback mode in while loop I am sending two frames and enable RX interrupt mode in which Receive Id will be process.

so is it correct?

#include "main.h"

#include "stm32f4xx_hal_can.h"
/* USER CODE BEGIN PM */


/* Private variables ---------------------------------------------------------*/
CAN_HandleTypeDef hcan1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN1_Init(void);

/**
* @brief This function handles CAN1 RX0 interrupt request.
* @PAram None
* @retval None
*/
void CAN1_TXIRQHandler(void)
{
 HAL_CAN_IRQHandler(&hcan1);
}
void CAN1_RX0IRQHandler(void)
{
 HAL_CAN_IRQHandler(&hcan1);
}
void CAN1_RX1IRQHandler(void)
{
 HAL_CAN_IRQHandler(&hcan1);
}
void CAN1_SCEIRQHandler(void)
{
 HAL_CAN_IRQHandler(&hcan1);
}
void WWDG_APPIRQHandler(void)
{

}

void CANRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
	CAN_RxHeaderTypeDef rx_header;
	uint8_t rx_data[8];

 static uint32_t counter0x3e8 = 0;
	static uint32_t counter0x244 = 0;


	if (HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &rx_header, rx_data) != HAL_OK)
	{
		Error_Handler();
	}
if(rx_header.StdId==0x3e8){
	counter0x3e8++;
}
else if(rx_header.StdId==0x244){
	counter0x244++;
}

}


void CANRxFifo0FullCallback(CAN_HandleTypeDef *hcan)
{

}
void CANRxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan)
{

}
void CANRxFifo1FullCallback(CAN_HandleTypeDef *hcan)
{

}
void CANTxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan)
{

}
void CANTxMailbox1CompleteCallback(CAN_HandleTypeDef *hcan)
{

}
void CANTxMailbox2CompleteCallback(CAN_HandleTypeDef *hcan)
{

}
void CANTxMailbox0AbortCallback(CAN_HandleTypeDef *hcan)
{

}
void CANTxMailbox1AbortCallback(CAN_HandleTypeDef *hcan)
{

}
void CANTxMailbox2AbortCallback(CAN_HandleTypeDef *hcan)
{

}
void CANSleepCallback(CAN_HandleTypeDef *hcan)
{

}
void CANWakeUpFromRxMsgCallback(CAN_HandleTypeDef *hcan)
{

}
void CANErrorCallback(CAN_HandleTypeDef *hcan)
{

}

int main(void)
{

	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	HAL_Init();

	/* Configure the system clock */
	SystemClock_Config();

	/*HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 0, 0); // Set priority
	HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn); // Enable interrupt*/

	/* USER CODE END 2 */
	HAL_NVIC_DisableIRQ(SPI2_IRQn);
	/*HAL_NVIC_DisableIRQ(WWDG_IRQn);*/
	//WWDG->CR = WWDG_CR_WDGA; // This disables the watchdog (clears the WDGA bit)

	/* Initialize all configured peripherals */
	MX_GPIO_Init();
	MX_CAN1_Init();




	/* Can initialization */
	if (HAL_CAN_Start(&hcan1) != HAL_OK)
	{
		Error_Handler();
	}


	while (1)
	{


		// Example: Transmit a CAN message
		CAN_TxHeaderTypeDef txHeader;
	 	const uint8_t tx_data[8] = {0x11};
		const uint8_t tx_data1[8] = {0x12};
		uint32_t tx_mailbox_used;

		txHeader.StdId = 0x3e8; // Example CAN ID
		txHeader.RTR = CAN_RTR_DATA;
		txHeader.IDE = CAN_ID_STD;
		txHeader.DLC = 8;

		if (HAL_CAN_AddTxMessage(&hcan1, &txHeader, tx_data, &tx_mailbox_used) != HAL_OK)
		{
			Error_Handler();
		}

		txHeader.StdId = 0x244; // Example CAN ID
				txHeader.RTR = CAN_RTR_DATA;
				txHeader.IDE = CAN_ID_STD;
				txHeader.DLC = 8;

		if (HAL_CAN_AddTxMessage(&hcan1, &txHeader, tx_data1, &tx_mailbox_used) != HAL_OK)
				{
					Error_Handler();
				}

		HAL_Delay(10);


	}


}


void SystemClock_Config(void)
{
	RCC_OscInitTypeDef RCC_OscInitStruct = {0};
	RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

	/** Configure the main internal regulator output voltage
	 */
	__HAL_RCC_PWR_CLK_ENABLE();
	__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

	/** Initializes the RCC Oscillators according to the specified parameters
	 * in the RCC_OscInitTypeDef structure.
	 */
	RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
	RCC_OscInitStruct.HSEState = RCC_HSE_ON;
	RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
	RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
	RCC_OscInitStruct.PLL.PLLM = 8;
	RCC_OscInitStruct.PLL.PLLN = 336;
	RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
	RCC_OscInitStruct.PLL.PLLQ = 7;
	if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
	{
		Error_Handler();
	}

	/** Initializes the CPU, AHB and APB buses clocks
	 */
	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_DIV4;
	RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

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


static void MX_CAN1_Init(void)
{



	/* USER CODE END CAN1_Init 1 */
	hcan1.Instance = CAN1;
	hcan1.Init.Prescaler = 6;
	hcan1.Init.Mode = CAN_MODE_LOOPBACK;
	hcan1.Init.SyncJumpWidth = CAN_SJW_1TQ;
	hcan1.Init.TimeSeg1 = CAN_BS1_11TQ;
	hcan1.Init.TimeSeg2 = CAN_BS2_2TQ;
	hcan1.Init.TimeTriggeredMode = DISABLE;
	hcan1.Init.AutoBusOff = DISABLE;
	hcan1.Init.AutoWakeUp = DISABLE;
	hcan1.Init.AutoRetransmission = ENABLE;
	hcan1.Init.ReceiveFifoLocked = ENABLE;
	hcan1.Init.TransmitFifoPriority = DISABLE;
	if (HAL_CAN_Init(&hcan1) != HAL_OK)
	{
		Error_Handler();
	}
	CAN_FilterTypeDef sFilterConfig;
	/* USER CODE BEGIN CAN1_Init 2 */
	 sFilterConfig.FilterBank = 0;
	 sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
	 sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
	 sFilterConfig.FilterIdHigh = 0x0000;
	 sFilterConfig.FilterIdLow = 0x0000;
	 sFilterConfig.FilterMaskIdHigh = 0x0000;
	 sFilterConfig.FilterMaskIdLow = 0x0000;
	 sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
	 sFilterConfig.FilterActivation = ENABLE;
	 sFilterConfig.SlaveStartFilterBank = 14;

	if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
	{
		Error_Handler();
	}


	/* Can initialization */
	/* USER CODE END CAN1_Init 2 */
	HAL_CAN_ActivateNotification(&hcan1, CAN_IT_TX_MAILBOX_EMPTY);
	HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_FULL);
	HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_OVERRUN);
	//HAL_CAN_ActivateNotification(&hcan1, CAN_IT_WAKEUP);


}


static void MX_GPIO_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStruct = {0};

	/* GPIO Ports Clock Enable */
	//__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOD_CLK_ENABLE();

	/*Configure GPIO pin Output Level */
	HAL_GPIO_WritePin(GPIOD, LD4_Pin|LD3_Pin|LD5_Pin|LD6_Pin, GPIO_PIN_RESET);

	/*Configure GPIO pin : B1_Pin */
	GPIO_InitStruct.Pin = B1_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

	/*Configure GPIO pins : LD4_Pin LD3_Pin LD5_Pin LD6_Pin */
	GPIO_InitStruct.Pin = LD4_Pin|LD3_Pin|LD5_Pin|LD6_Pin;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

}



void Error_Handler(void)
{
	/* USER CODE BEGIN Error_Handler_Debug */
	/* User can add his own implementation to report the HAL error return state */
	__disable_irq();
	while (1)
	{
	}
	/* USER CODE END Error_Handler_Debug */
}


/*I want to implement CAN communication in normal mode for STM32F407 discovery
board using HAL library functions. I want to transmit message id 0x123 with
tx_data[8] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08} in
polling mode. After that I want to receive this message id in interrupt based
mode by enabling CAN1_RX0 interrupt mode. */