Turn on suggestions
Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.
Showing results for
- STMicroelectronics Community
- STM32 MCUs
- STM32 MCUs Boards and hardware tools
- Re: STM32F103 UART interrupt not working
Options
- Subscribe to RSS Feed
- Mark Topic as New
- Mark Topic as Read
- Float this Topic for Current User
- Bookmark
- Subscribe
- Mute
- Printer Friendly Page
STM32F103 UART interrupt not working
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 03:04 AM
Hello, I'm building a project where I will use CAN, UART and a TIMER. All of these work with an interrupt. How it works: I get data via CAN and use a TIMER to send a Request on the CANbus. With the UART I need to receive some commands that will trigger some functions. I have provided my code. In this code everything is working except for the UART interrupt. I had a different project with UART where everything was in the main, so I copied that to see if that is working, but it doesn't work. The UART interrupt is not getting triggered, but in the separate project it is working where I only use UART. What is wrong?
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <engine_control.h>
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
// Uncomment the next line to enable debug prints
//#define DEBUGG
#ifdef DEBUGG
#define DebugPrint(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DebugPrint(fmt, ...)
#endif
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
CAN_HandleTypeDef hcan;
TIM_HandleTypeDef htim14;
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
/* USER CODE BEGIN PV */
CAN_RxHeaderTypeDef can_rxheader; //CAN Bus Receive Header
CAN_TxHeaderTypeDef can_txheader; //CAN Bus Transmit Header
uint8_t can_rx[8]; //CAN Bus Receive Buffer
//char received_char; // RS232 received
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_TIM14_Init(void);
/* USER CODE BEGIN PFP */
// Enable Serial print via USART1
#ifdef __GNUC__
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
PUTCHAR_PROTOTYPE {
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
return ch;
}
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//+++++++++++++++++++++++
#define BUFFER_SIZE 50
#define XYZ_BUFFER_SIZE 5
// Global variables
char received_char;
char message_buffer[BUFFER_SIZE];
uint8_t message_index = 0;
uint8_t message_type = 0; // 0: No message, 1: X, 2: Y, 3: Z, 4: Array
// Ring buffer for X, Y, Z messages
char xyz_ring_buffer[XYZ_BUFFER_SIZE];
volatile uint8_t xyz_ring_head = 0;
volatile uint8_t xyz_ring_tail = 0;
uint8_t xyz_buffer_count = 0;
// Ring buffer for character array message
char array_ring_buffer[BUFFER_SIZE];
volatile uint8_t array_ring_head = 0;
volatile uint8_t array_ring_tail = 0;
uint8_t array_buffer_count = 0;
//uint8_t tx_battery_data[] = {100, 49, 50, 44, 50, 103};
//uint8_t tx_fuel_data[] = {101, 53, 65, 44, 49, 142};
//uint8_t tx_hour_data[] = {102, 51, 49, 50, 57, 44, 50, 53, 60};
//uint8_t tx_rpm_data[] = {103, 49, 53, 51, 56, 44, 54, 51};
uint8_t tx_data[] = { 100, 49, 50, 46, 50, 101, 53, 56, 46, 52, 102, 51, 49, 50,
57, 46, 50, 53, 103, 49, 53, 51, 56, 46, 54, 195 };
uint8_t tx_status[2] = { 3, 9 };
uint8_t tx_alarm[2] = { 37, 251 };
double voltage = 12.2;
double fuel = 87.19;
double hour = 51427.75;
double rpm = 1409.792;
double test[4];
// Reset ring buffer
void UART_reset_xyz() {
xyz_ring_head = 0;
xyz_ring_tail = 0;
}
// Function to handle UART error
void UART_Error_Handler(void) {
// Toggle led1 when UART error occurred
HAL_GPIO_TogglePin(GPIOF, LED1_Pin);
}
// UART callback function
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
if (huart->Instance == USART2) {
// Check if there's an overrun error
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE)) {
__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_ORE); // Clear the overrun error flag
UART_Error_Handler();
}
// Check if there's a framing error
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE)) {
__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_FE); // Clear the framing error flag
UART_Error_Handler();
}
// Check if there's a noise error
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_NE)) {
__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_NE); // Clear the noise error flag
UART_Error_Handler();
}
// Check if there's a parity error
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE)) {
__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_PE); // Clear the parity error flag
UART_Error_Handler();
}
}
}
// Calculate the CRC-8 for checksum
uint8_t calculate_CRC8(const uint8_t *data, size_t length) {
uint8_t crc = 0;
for (size_t i = 0; i < length; i++) {
crc ^= data[i];
for (int j = 0; j < 8; j++) {
if (crc & 0x80) {
crc = (crc << 1) ^ 0x07; // Polynomial for CRC-8 (0x07)
} else {
crc = crc << 1;
}
}
}
return crc;
}
// Function to convert double to ASCII characters
void double_to_ASCII(double value, char *buffer, uint8_t *index) {
uint8_t len = snprintf(NULL, 0, "%.2f", value); // Determine the length of the ASCII representation
snprintf(&buffer[*index], len + 1, "%.2f", value); // Convert double to ASCII and store in the buffer
*index += len; // Update the index to point to the next position in the buffer
}
// Function to send data over UART
void send_double_array_UART(double *values, uint8_t num_values) {
char buffer[100]; // Adjust buffer size based on the maximum possible size needed
uint8_t index = 0; // Initialize the index for buffer position
uint8_t identifier = 100; // Initialize the identifier starting from 100
for (uint8_t i = 0; i < num_values; ++i) {
buffer[index++] = identifier++; // Add the identifier before each double
double_to_ASCII(values[i], buffer, &index);
// if (i != num_values - 1) {
// buffer[index++] = ','; // Add a delimiter between values (comma in this case)
// }
}
// Calculate CRC8 for the entire buffer (excluding the last character, which will be the CRC8)
uint8_t crc = calculate_CRC8((uint8_t *)buffer, index);
buffer[index++] = crc; // Convert CRC8 value to ASCII and add to buffer
// buffer[index] = '\0'; // Add a null terminator to mark the end of the string
// Send the string over UART
HAL_UART_Transmit(&huart2, (uint8_t *)buffer, strlen(buffer), HAL_MAX_DELAY);
}
// Send message UART
void send_msg(uint8_t *data, uint16_t size, const char *data_name) {
while (HAL_UART_GetState(&huart2) == HAL_UART_STATE_READY)
;
if (HAL_UART_Transmit_IT(&huart2, data, size) == HAL_OK) {
printf("Send %s data\r\n", data_name);
} else {
HAL_UART_ErrorCallback(&huart2);
DebugPrint("Failed to send %s data\r\n", data_name);
}
}
// Send data over UART
void UART_send_data(void) {
send_msg(tx_data, sizeof(tx_data), "Data");
}
// Send status over UART
void UART_send_status(void) {
send_msg(tx_status, sizeof(tx_status), "Status");
}
// Send alarm over UART
void UART_send_alarm(void) {
send_msg(tx_alarm, sizeof(tx_alarm), "Alarm");
}
void UART_process_xyz() {
// Data available in the buffer
if (xyz_ring_tail != xyz_ring_head) {
DebugPrint("Received: %c\r\n", xyz_ring_buffer[xyz_ring_tail]);
switch (xyz_ring_buffer[xyz_ring_tail]) {
case 'X':
// UART_send_data();
send_double_array_UART(test, sizeof(test) / sizeof(test[0]));
DebugPrint("Data request \r\n");
break;
case 'Y':
UART_send_alarm();
DebugPrint("Alarm request \r\n");
break;
case 'Z':
UART_send_status();
DebugPrint("Status request \r\n");
break;
default:
printf("Incorrect UART message \r\n");
}
xyz_ring_tail = (xyz_ring_tail + 1) % XYZ_BUFFER_SIZE;
xyz_buffer_count--;
}
}
//void UART_process_array() {
//
//// char data[];
//
// if (array_ring_tail != array_ring_head) {
//
// char array_message = array_ring_buffer[array_ring_tail];
// // Process arrayMessage as needed
// array_ring_tail = (array_ring_tail + 1) % BUFFER_SIZE;
// array_buffer_count--;
// }
//
//}
// UART interrupt
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
printf("RS232 Interrupt \r\n");
// Check if correct UART is triggered
if (huart->Instance == USART2) {
// Check if UART is received correctly
if (HAL_UART_Receive_IT(&huart2, (uint8_t*)&received_char, 1)
== HAL_OK) {
// Check for the type of message
switch (message_type) {
// No message received yet
case 0:
// Decide the message type
if (received_char == 'X') {
message_type = 1;
} else if (received_char == 'Y') {
message_type = 2;
} else if (received_char == 'Z') {
message_type = 3;
} else {
// Data message received
message_type = 4;
message_index = 0;
message_buffer[message_index++] = received_char;
}
break;
case 1: // X message
case 2: // Y message
case 3: // Z message
// Store X, Y, Z messages in the ring buffer
if (xyz_buffer_count < XYZ_BUFFER_SIZE) {
xyz_ring_buffer[xyz_ring_head] = received_char;
xyz_ring_head = (xyz_ring_head + 1) % XYZ_BUFFER_SIZE;
xyz_buffer_count++;
} else {
// UART_reset_xyz();
// Overwrite the last received character in the xyzeRingBuffer
xyz_ring_buffer[xyz_ring_tail] = received_char;
xyz_ring_tail = (xyz_ring_tail + 1) % XYZ_BUFFER_SIZE;
}
break;
// Array message
case 4:
// Store array message in the ring buffer
if (array_buffer_count < BUFFER_SIZE) {
array_ring_buffer[array_ring_head] = received_char;
array_ring_head = (array_ring_head + 1) % BUFFER_SIZE;
array_buffer_count++;
} else {
array_ring_tail = 0;
array_ring_head = 0;
array_buffer_count = 0;
}
if (message_index < BUFFER_SIZE - 1) {
message_buffer[message_index++] = received_char;
} else {
// Process complete array message (message_buffer contains the data)
message_type = 0; // Reset message type
}
break;
}
} else {
// Error handler
HAL_UART_ErrorCallback(&huart2);
DebugPrint("UART no Data \r\n");
}
// Restart reception
HAL_UART_Receive_IT(&huart2, (uint8_t*)&received_char, 1);
}
}
//+++++++++++++++++++++++
//uint8_t rx_buff[2];
//-----------------------------------
// UART interrupt
//void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
//
// printf("UART interrupt");
//
// HAL_UART_Receive_IT(&huart2, rx_buff, 2);
//
// // Check if correct UART is triggered
// if (huart->Instance == USART2) {
//
// printf("RS232 MSG \r\n");
//
// // Check if UART is received correctly
// if (HAL_UART_Receive_IT(&huart2, (uint8_t*)&received_char, 1) == HAL_OK) {
// // Store received characters in the ring buffer
// queue_request(&received_char);
//
// // Restart reception
// HAL_UART_Receive_IT(&huart2, (uint8_t*)&received_char, 1);
// }
//
// // Restart reception
// HAL_UART_Receive_IT(&huart2, (uint8_t*)&received_char, 1);
// }
//}
//-----------------------------------
volatile uint8_t request_timer_flag = 0;
// Callback timer interrupt for sending request on CANbus
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
if (htim == &htim14 ) {
HAL_GPIO_TogglePin(GPIOF, LED1_Pin);
request_timer_flag = 1;
}
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
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();
MX_USART1_UART_Init();
MX_USART2_UART_Init();
MX_TIM14_Init();
/* USER CODE BEGIN 2 */
// UART interrupt
HAL_UART_Receive_IT(&huart2, (uint8_t*)&received_char, 1);
// Start timer
HAL_TIM_Base_Start_IT(&htim14);
// CAN filters
CAN_filter(0, FILTER_ID1, FILTER_MASK1, CAN_RX_FIFO0, &hcan);
CAN_filter(1, FILTER_ID2, FILTER_MASK2, CAN_RX_FIFO0, &hcan);
CAN_filter(2, FILTER_ID3, FILTER_MASK3, CAN_RX_FIFO0, &hcan);
CAN_filter(3, FILTER_ID4, FILTER_MASK4, CAN_RX_FIFO1, &hcan);
CAN_filter(4, FILTER_ID5, FILTER_MASK5, CAN_RX_FIFO1, &hcan);
CAN_filter(5, FILTER_ID6, FILTER_MASK6, CAN_RX_FIFO1, &hcan);
CAN_filter(6, FILTER_ID7, FILTER_MASK7, CAN_RX_FIFO1, &hcan);
printf("test \r\n");
// Enable CAN
if (HAL_CAN_Start(&hcan) != HAL_OK) {
CAN_restart(&hcan);
}
// Send out name of this node
if (CAN_name() == NAME_ERROR) {
CAN_restart(&hcan);
}
// CAN interrupts
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO1_MSG_PENDING);
HAL_CAN_ActivateNotification(&hcan, CAN_IT_ERROR);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1) {
if (request_timer_flag) {
request_PGN(TOTAL_ENGINE_HOUR);
request_timer_flag = 0; // Reset flag
}
// Process incoming CAN messages
CAN_process_msg();
// TEST CODE
test[0] = voltage;
test[1] = fuel;
test[2] = hour;
test[3] = rpm;
UART_process_xyz();
// ++++++
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* 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 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.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();
}
/** 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_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/**
* @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 = CAN1;
hcan.Init.Prescaler = 8;
hcan.Init.Mode = CAN_MODE_NORMAL;
hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan.Init.TimeSeg1 = CAN_BS1_15TQ;
hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
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 */
/* USER CODE END CAN_Init 2 */
}
/**
* @brief TIM14 Initialization Function
* @PAram None
* @retval None
*/
static void MX_TIM14_Init(void)
{
/* USER CODE BEGIN TIM14_Init 0 */
/* USER CODE END TIM14_Init 0 */
/* USER CODE BEGIN TIM14_Init 1 */
/* USER CODE END TIM14_Init 1 */
htim14.Instance = TIM14;
htim14.Init.Prescaler = 8000;
htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
htim14.Init.Period = 9999;
htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM14_Init 2 */
/* USER CODE END TIM14_Init 2 */
}
/**
* @brief USART1 Initialization Function
* @PAram None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
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)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
}
/**
* @brief USART2 Initialization Function
* @PAram None
* @retval None
*/
static void MX_USART2_UART_Init(void)
{
/* USER CODE BEGIN USART2_Init 0 */
/* USER CODE END USART2_Init 0 */
/* USER CODE BEGIN USART2_Init 1 */
/* USER CODE END USART2_Init 1 */
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();
}
/* USER CODE BEGIN USART2_Init 2 */
/* USER CODE END USART2_Init 2 */
}
Solved! Go to Solution.
Labels:
- Labels:
-
ST boards
-
STM32F1 Series
1 ACCEPTED SOLUTION
Accepted Solutions
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 04:27 AM
I got it working. I didn't look at the PIN settings. The receive pin (PA3) of USART2 was set to GPIO mode, but it should be input mode.
6 REPLIES 6
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 03:07 AM
Hello,
Did you activate the interrupt for the UART? (check if the NVIC interrupt line for your UART is configured).
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.
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 03:42 AM
Yes, I activated the interrupt for UART, CAN, TIMER.
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 04:02 AM
Try to isolate UART functions and built a simple application with only UART and see if the issue still happen.
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.
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 04:13 AM
So I followed this link https://wiki.st.com/stm32mcu/wiki/Getting_started_with_UART#UART_with_Interrupt to test if it was working, but this also doesn't work. The interrupt won't trigger. Below is the code.
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <engine_control.h>
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
// Uncomment the next line to enable debug prints
//#define DEBUGG
#ifdef DEBUGG
#define DebugPrint(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DebugPrint(fmt, ...)
#endif
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
CAN_HandleTypeDef hcan;
TIM_HandleTypeDef htim14;
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
/* USER CODE BEGIN PV */
CAN_RxHeaderTypeDef can_rxheader; //CAN Bus Receive Header
CAN_TxHeaderTypeDef can_txheader; //CAN Bus Transmit Header
uint8_t can_rx[8]; //CAN Bus Receive Buffer
//char received_char; // RS232 received
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_TIM14_Init(void);
/* USER CODE BEGIN PFP */
// Enable Serial print via USART1
#ifdef __GNUC__
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
PUTCHAR_PROTOTYPE {
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
return ch;
}
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t rx_buff[2];
//-----------------------------------
// UART interrupt
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
HAL_GPIO_TogglePin(GPIOF, LED2_Pin);
printf("UART interrupt");
// Check if correct UART is triggered
if (huart->Instance == USART2) {
printf("RS232 MSG \r\n");
}
HAL_UART_Receive_IT(&huart2, rx_buff, 2);
}
//-----------------------------------
volatile uint8_t request_timer_flag = 0;
// Callback timer interrupt for sending request on CANbus
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
if (htim == &htim14 ) {
HAL_GPIO_TogglePin(GPIOF, LED1_Pin);
request_timer_flag = 1;
}
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
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();
MX_USART1_UART_Init();
MX_USART2_UART_Init();
MX_TIM14_Init();
/* USER CODE BEGIN 2 */
// UART interrupt
HAL_UART_Receive_IT(&huart2, rx_buff, 2);
// Start timer
HAL_TIM_Base_Start_IT(&htim14);
// CAN filters
CAN_filter(0, FILTER_ID1, FILTER_MASK1, CAN_RX_FIFO0, &hcan);
CAN_filter(1, FILTER_ID2, FILTER_MASK2, CAN_RX_FIFO0, &hcan);
CAN_filter(2, FILTER_ID3, FILTER_MASK3, CAN_RX_FIFO0, &hcan);
CAN_filter(3, FILTER_ID4, FILTER_MASK4, CAN_RX_FIFO1, &hcan);
CAN_filter(4, FILTER_ID5, FILTER_MASK5, CAN_RX_FIFO1, &hcan);
CAN_filter(5, FILTER_ID6, FILTER_MASK6, CAN_RX_FIFO1, &hcan);
CAN_filter(6, FILTER_ID7, FILTER_MASK7, CAN_RX_FIFO1, &hcan);
printf("test \r\n");
// Enable CAN
if (HAL_CAN_Start(&hcan) != HAL_OK) {
CAN_restart(&hcan);
}
// Send out name of this node
if (CAN_name() == NAME_ERROR) {
CAN_restart(&hcan);
}
// CAN interrupts
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO1_MSG_PENDING);
HAL_CAN_ActivateNotification(&hcan, CAN_IT_ERROR);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1) {
if (request_timer_flag) {
request_PGN(TOTAL_ENGINE_HOUR);
request_timer_flag = 0; // Reset flag
}
// Process incoming CAN messages
CAN_process_msg();
// Process RS232 communication
// RS232_process_request();
// printf("STATE MAIN: %d \r\n", engine_info.engine_state);
// printf("AMBER: %d \r\n", active_lamp.amber);
// printf("MIL: %d \r\n", active_lamp.mil);
// printf("PROTECT: %d \r\n", active_lamp.protect);
// printf("RED: %d \r\n", active_lamp.red);
// printf("\r\n");
// printf("ALARMEN: %d \r\n", engine_info.alarm);
// printf("\r\n");
// printf("STATE: %d \r\n", engine_data.engine_state);
// printf("\r\n");
// printf("++++++BATT+++++++: %0.2f \r\n", engine_data.battery_voltage);
// printf("++++++FUEL+++++++: %0.2f \r\n", engine_data.fuel_level);
// printf("++++++HOUR+++++++: %0.2f \r\n", engine_data.engine_hour);
// printf("++++++SPEED++++++: %0.2f \r\n", engine_data.engine_speed);
// printf("++++++OIL++++++++: %0.2f \r\n", engine_data.oil_pressure);
// printf("++++++TEMP+++++++: %0.2f \r\n", engine_data.engine_temperature);
// printf("++++++ECO++++++++: %0.2f \r\n", engine_data.fuel_economy);
// printf("++++++STATE++++++: %d \r\n", engine_data.engine_state);
// printf("\r\n");
// printf("\r\n");
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* 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 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.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();
}
/** 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_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/**
* @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 = CAN1;
hcan.Init.Prescaler = 8;
hcan.Init.Mode = CAN_MODE_NORMAL;
hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan.Init.TimeSeg1 = CAN_BS1_15TQ;
hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
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 */
/* USER CODE END CAN_Init 2 */
}
/**
* @brief TIM14 Initialization Function
* @PAram None
* @retval None
*/
static void MX_TIM14_Init(void)
{
/* USER CODE BEGIN TIM14_Init 0 */
/* USER CODE END TIM14_Init 0 */
/* USER CODE BEGIN TIM14_Init 1 */
/* USER CODE END TIM14_Init 1 */
htim14.Instance = TIM14;
htim14.Init.Prescaler = 8000;
htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
htim14.Init.Period = 9999;
htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM14_Init 2 */
/* USER CODE END TIM14_Init 2 */
}
/**
* @brief USART1 Initialization Function
* @PAram None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
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)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
}
/**
* @brief USART2 Initialization Function
* @PAram None
* @retval None
*/
static void MX_USART2_UART_Init(void)
{
/* USER CODE BEGIN USART2_Init 0 */
/* USER CODE END USART2_Init 0 */
/* USER CODE BEGIN USART2_Init 1 */
/* USER CODE END USART2_Init 1 */
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();
}
/* USER CODE BEGIN USART2_Init 2 */
/* USER CODE END USART2_Init 2 */
}
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 04:27 AM
I got it working. I didn't look at the PIN settings. The receive pin (PA3) of USART2 was set to GPIO mode, but it should be input mode.
Options
- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content
2024-01-23 04:51 AM
Well, that's why you need to isolate the function having the issue to surround it quickly ;).
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.
Related Content
- FreeRTOS on STM32G0B1: Unable to use as I2C Slave in STM32 MCUs Embedded software
- Issue with DMA and ADC on STM32 Nucleo C031C6T6 in STM32 MCUs Products
- NUCLEOL152RE board adc_buffer not being written to in STM32 MCUs Embedded software
- STM32U599 Hard fault inside touchgfx::Application::draw(touchgfx::Rect&) in STM32 MCUs TouchGFX and GUI
- Can't get UART Rx interrupt to work in STM32 MCUs Embedded software