Associate III

Solved

CAN TX

Forum|Forum|1 year ago
December 23, 2024
4 replies
3943 views

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

Best answer by mƎALLEm

If in loopback mode is working there is no issue in the MCU nor in your software. I don't think there is an issue with the HW as at least you received one ID. I suspect you have an issue with your CAN analyzer.

A

Ash1Author

Associate III

Hi

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

B.R

Ashish

Peter BENSCH

Technical Moderator

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

In order to give better visibility on the answered topics, please click on Accept as Solution on the reply which solved your issue or answered your question.

mƎALLEm

Technical Moderator

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

To give better visibility on the answered topics, please click "Best answer" on the reply which solved your issue or answered your question.

A

Ash1Author

Associate III

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

Technical Moderator

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?

To give better visibility on the answered topics, please click "Best answer" on the reply which solved your issue or answered your question.

mƎALLEm

Technical Moderator

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

To give better visibility on the answered topics, please click "Best answer" on the reply which solved your issue or answered your question.

A

Ash1Author

Associate III

Hi

How Can I attach project in reply

A

Ash1Author

Associate III

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. */

Sign up

Login with SSO

Login to the community

Login with SSO

Scanning file for viruses.

This file cannot be downloaded