feat: Update UART heartbeat message format, adjust UART2 baud rate and oversampling

feat: Enhance UART reception handling with IDLE line detection and hex dump functionality
bad uart tx
2025-10-30 12:40:01 +08:00 · 2025-10-30 12:25:50 +08:00 · 2025-10-30 12:01:58 +08:00
5 changed files with 214 additions and 36 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -0,0 +1,3 @@
+{
+    "editor.formatOnSave": false
+}
--- a/Core/Src/main.c
+++ b/Core/Src/main.c
@ -22,6 +22,8 @@
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
 #include <stdio.h>
+#include <string.h>
+#include <stdbool.h>

 /* USER CODE END Includes */

@ -45,7 +47,9 @@ UART_HandleTypeDef huart1;
 UART_HandleTypeDef huart2;

 /* USER CODE BEGIN PV */
-
+static uint8_t rx_buf[64];
+static bool rx_complete = false;
+static volatile uint16_t rx_length = 0;
 /* USER CODE END PV */

 /* Private function prototypes -----------------------------------------------*/
@ -54,13 +58,72 @@ static void MX_GPIO_Init(void);
 static void MX_USART1_UART_Init(void);
 static void MX_USART2_UART_Init(void);
 /* USER CODE BEGIN PFP */
-
+static void hex_dump(const uint8_t *data, uint16_t len);
 /* USER CODE END PFP */

 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
 static char heartbeat_buf[64];

+/**
+  * @brief  Print hex dump in ESP-IDF style
+  * @param  data: pointer to data buffer
+  * @param  len: length of data
+  * @retval None
+  */
+static void hex_dump(const uint8_t *data, uint16_t len)
+{
+	char line_buf[80];
+	
+	for (uint16_t i = 0; i < len; i += 16) {
+		// Print address
+		int pos = snprintf(line_buf, sizeof(line_buf), "0x%08lx   ", (unsigned long)(data + i));
+		
+		// Print hex values (first 8 bytes)
+		for (int j = 0; j < 8; j++) {
+			if (i + j < len) {
+				pos += snprintf(line_buf + pos, sizeof(line_buf) - pos, "%02x ", data[i + j]);
+			} else {
+				pos += snprintf(line_buf + pos, sizeof(line_buf) - pos, "   ");
+			}
+		}
+		
+		// Space between two groups
+		pos += snprintf(line_buf + pos, sizeof(line_buf) - pos, " ");
+		
+		// Print hex values (second 8 bytes)
+		for (int j = 8; j < 16; j++) {
+			if (i + j < len) {
+				pos += snprintf(line_buf + pos, sizeof(line_buf) - pos, "%02x ", data[i + j]);
+			} else {
+				pos += snprintf(line_buf + pos, sizeof(line_buf) - pos, "   ");
+			}
+		}
+		
+		// Print ASCII representation
+		pos += snprintf(line_buf + pos, sizeof(line_buf) - pos, " |");
+		for (int j = 0; j < 16; j++) {
+			if (i + j < len) {
+				uint8_t c = data[i + j];
+				if (c >= 32 && c <= 126) {
+					line_buf[pos++] = c;
+				} else {
+					line_buf[pos++] = '.';
+				}
+			} else {
+				// Pad with space if beyond data length
+				line_buf[pos++] = ' ';
+			}
+		}
+		line_buf[pos++] = '|';
+		line_buf[pos++] = '\r';
+		line_buf[pos++] = '\n';
+		
+		// Send line to UART1
+		HAL_UART_Transmit(&huart1, (uint8_t *)line_buf, (uint16_t)pos, HAL_MAX_DELAY);
+	}
+}
+
 /* USER CODE END 0 */

 /**
@ -95,26 +158,53 @@ int main(void)
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
-
+  /* Enable UART IDLE interrupt */
+  __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
+  /* Start UART2 reception in interrupt mode */
+  HAL_UART_Receive_IT(&huart2, rx_buf, sizeof(rx_buf));
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
 	while (1) {
-		HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6);
-		/* Heartbeat: emit tick timestamp over UART1 and blink the PB6 LED */
-		int msg_len = snprintf(heartbeat_buf, sizeof(heartbeat_buf),
-							   "PB6 heartbeat %lu\r\n", (unsigned long)HAL_GetTick());
-		if (msg_len > 0) {
-			if (msg_len >= (int)sizeof(heartbeat_buf)) {
-				msg_len = (int)sizeof(heartbeat_buf) - 1;
-			}
-			HAL_UART_Transmit(&huart1, (uint8_t *)heartbeat_buf, (uint16_t)msg_len,
-							  HAL_MAX_DELAY);
-		}
-		HAL_Delay(1000);
-    /* USER CODE END WHILE */
 		
+		/* Check if data received from UART2 */
+		if (rx_complete) {
+			rx_complete = false;
+			uint16_t len = rx_length;
+			
+			/* Print header */
+			char header[32];
+			int header_len = snprintf(header, sizeof(header), "RX[%u]:\r\n", len);
+			HAL_UART_Transmit(&huart1, (uint8_t *)header, (uint16_t)header_len, HAL_MAX_DELAY);
+			
+			/* Print received buffer as hex dump */
+			hex_dump(rx_buf, len);
+			
+			/* Clear buffer before re-arming */
+			memset(rx_buf, 0, sizeof(rx_buf));
+			
+			/* Re-arm UART2 reception */
+			HAL_UART_Receive_IT(&huart2, rx_buf, sizeof(rx_buf));
+		}
+
+		static uint32_t last_toggle_timestamp;
+		if (HAL_GetTick() - last_toggle_timestamp >= 1000) {
+			HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6);
+			/* Heartbeat: emit tick timestamp over UART1 and blink the PB6 LED */
+			int msg_len = snprintf(heartbeat_buf, sizeof(heartbeat_buf),
+									"%lu PB6 heartbeat\r\n", (unsigned long)HAL_GetTick());
+			if (msg_len > 0) {
+				if (msg_len >= (int)sizeof(heartbeat_buf)) {
+					msg_len = (int)sizeof(heartbeat_buf) - 1;
+				}
+				HAL_UART_Transmit(&huart1, (uint8_t *)heartbeat_buf, (uint16_t)msg_len,
+									HAL_MAX_DELAY);
+			}
+			last_toggle_timestamp = HAL_GetTick();
+		}
+
+    /* USER CODE END WHILE */
    /* USER CODE BEGIN 3 */
 	}
  /* USER CODE END 3 */
@ -215,13 +305,13 @@ static void MX_USART2_UART_Init(void)

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
-  huart2.Init.BaudRate = 115200;
+  huart2.Init.BaudRate = 14400;
  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;
+  huart2.Init.OverSampling = UART_OVERSAMPLING_8;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
@ -275,6 +365,38 @@ static void MX_GPIO_Init(void)

 /* USER CODE BEGIN 4 */

+/**
+  * @brief  UART IDLE line detected callback
+  * @note   This is called from USART2_IRQHandler when IDLE interrupt occurs
+  * @retval None
+  */
+void UART_IDLE_Callback(UART_HandleTypeDef *huart)
+{
+	if (huart->Instance == USART2) {
+		if (huart->RxState != HAL_UART_STATE_BUSY_RX) {
+			/* Not in reception state, ignore */
+			return;
+		}
+		/* Calculate how many bytes were actually received */
+
+		/**
+		 * RxXferCount is a countdown timer maintained by the HAL library that
+		 * decrements with each byte received. Subtracting it from the total
+		 * gives you the actual number of bytes that made it into the buffer.
+		 */
+		rx_length = sizeof(rx_buf) - huart->RxXferCount;
+		
+		/* Only process if we actually received data */
+		if (rx_length > 0) {
+			/* Abort the ongoing reception */
+			HAL_UART_AbortReceive_IT(&huart2);
+			
+			/* Signal that data is ready */
+			rx_complete = true;
+		}
+	}
+}
+
 /* USER CODE END 4 */

 /**
--- a/Core/Src/stm32f4xx_hal_msp.c
+++ b/Core/Src/stm32f4xx_hal_msp.c
@ -108,6 +108,10 @@ void HAL_UART_MspInit(UART_HandleTypeDef* huart)
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

+    /* USART1 interrupt Init */
+    HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
+    HAL_NVIC_EnableIRQ(USART1_IRQn);
+
    /* USER CODE BEGIN USART1_MspInit 1 */

    /* USER CODE END USART1_MspInit 1 */
@ -132,6 +136,10 @@ void HAL_UART_MspInit(UART_HandleTypeDef* huart)
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

+    /* USART2 interrupt Init */
+    HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
+    HAL_NVIC_EnableIRQ(USART2_IRQn);
+
    /* USER CODE BEGIN USART2_MspInit 1 */

    /* USER CODE END USART2_MspInit 1 */
@ -161,6 +169,9 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);

+    /* USART1 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART1_IRQn);
+
    /* USER CODE BEGIN USART1_MspDeInit 1 */

    /* USER CODE END USART1_MspDeInit 1 */
@ -179,6 +190,9 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
    */
    HAL_GPIO_DeInit(GPIOA, USART_TX_Pin|USART_RX_Pin);

+    /* USART2 interrupt DeInit */
+    HAL_NVIC_DisableIRQ(USART2_IRQn);
+
    /* USER CODE BEGIN USART2_MspDeInit 1 */

    /* USER CODE END USART2_MspDeInit 1 */
--- a/Core/Src/stm32f4xx_it.c
+++ b/Core/Src/stm32f4xx_it.c
@ -55,7 +55,8 @@
 /* USER CODE END 0 */

 /* External variables --------------------------------------------------------*/
-
+extern UART_HandleTypeDef huart1;
+extern UART_HandleTypeDef huart2;
 /* USER CODE BEGIN EV */

 /* USER CODE END EV */
@ -198,6 +199,42 @@ void SysTick_Handler(void)
 /* please refer to the startup file (startup_stm32f4xx.s).                    */
 /******************************************************************************/

+/**
+  * @brief This function handles USART1 global interrupt.
+  */
+void USART1_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART1_IRQn 0 */
+
+  /* USER CODE END USART1_IRQn 0 */
+  HAL_UART_IRQHandler(&huart1);
+  /* USER CODE BEGIN USART1_IRQn 1 */
+
+  /* USER CODE END USART1_IRQn 1 */
+}
+
+/**
+  * @brief This function handles USART2 global interrupt.
+  */
+void USART2_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART2_IRQn 0 */
+  /* Check for IDLE line detection */
+  if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE)) {
+    /* Clear IDLE flag by reading SR and DR */
+    __HAL_UART_CLEAR_IDLEFLAG(&huart2);
+    
+    /* Call custom IDLE callback */
+    extern void UART_IDLE_Callback(UART_HandleTypeDef *huart);
+    UART_IDLE_Callback(&huart2);
+  }
+  /* USER CODE END USART2_IRQn 0 */
+  HAL_UART_IRQHandler(&huart2);
+  /* USER CODE BEGIN USART2_IRQn 1 */
+
+  /* USER CODE END USART2_IRQn 1 */
+}
+
 /* USER CODE BEGIN 1 */

 /* USER CODE END 1 */
--- a/stmf411re_test.ioc
+++ b/stmf411re_test.ioc
@ -123,42 +123,44 @@ ProjectManager.UAScriptAfterPath=
 ProjectManager.UAScriptBeforePath=
 ProjectManager.UnderRoot=false
 ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_USART1_UART_Init-USART1-false-HAL-true,4-MX_USART2_UART_Init-USART2-false-HAL-true
-RCC.48MHZClocksFreq_Value=48000000
-RCC.AHBFreq_Value=48000000
+RCC.48MHZClocksFreq_Value=96000000
+RCC.AHBFreq_Value=96000000
+RCC.APB1CLKDivider=RCC_HCLK_DIV2
 RCC.APB1Freq_Value=48000000
-RCC.APB1TimFreq_Value=48000000
-RCC.APB2Freq_Value=48000000
-RCC.APB2TimFreq_Value=48000000
-RCC.CortexFreq_Value=48000000
-RCC.EthernetFreq_Value=48000000
-RCC.FCLKCortexFreq_Value=48000000
-RCC.FLatency-AdvancedSettings=FLASH_LATENCY_1
+RCC.APB1TimFreq_Value=96000000
+RCC.APB2Freq_Value=96000000
+RCC.APB2TimFreq_Value=96000000
+RCC.CortexFreq_Value=96000000
+RCC.EthernetFreq_Value=96000000
+RCC.FCLKCortexFreq_Value=96000000
+RCC.FLatency-AdvancedSettings=FLASH_LATENCY_3
 RCC.FamilyName=M
-RCC.HCLKFreq_Value=48000000
+RCC.HCLKFreq_Value=96000000
 RCC.HSE_VALUE=8000000
 RCC.HSI_VALUE=16000000
 RCC.I2SClocksFreq_Value=48000000
-RCC.IPParameters=48MHZClocksFreq_Value,AHBFreq_Value,APB1Freq_Value,APB1TimFreq_Value,APB2Freq_Value,APB2TimFreq_Value,CortexFreq_Value,EthernetFreq_Value,FCLKCortexFreq_Value,FLatency-AdvancedSettings,FamilyName,HCLKFreq_Value,HSE_VALUE,HSI_VALUE,I2SClocksFreq_Value,LSE_VALUE,LSI_VALUE,MCO1PinFreq_Value,MCO2PinFreq_Value,PLLCLKFreq_Value,PLLM,PLLP,PLLQCLKFreq_Value,PLLSourceVirtual,PWR_Regulator_Voltage_Scale,RCC_MCO1Source,RCC_MCODiv1,RTCFreq_Value,RTCHSEDivFreq_Value,SYSCLKFreq_VALUE,SYSCLKSource,VCOI2SOutputFreq_Value,VCOInputFreq_Value,VCOInputMFreq_Value,VCOOutputFreq_Value,VcooutputI2S
+RCC.IPParameters=48MHZClocksFreq_Value,AHBFreq_Value,APB1CLKDivider,APB1Freq_Value,APB1TimFreq_Value,APB2Freq_Value,APB2TimFreq_Value,CortexFreq_Value,EthernetFreq_Value,FCLKCortexFreq_Value,FLatency-AdvancedSettings,FamilyName,HCLKFreq_Value,HSE_VALUE,HSI_VALUE,I2SClocksFreq_Value,LSE_VALUE,LSI_VALUE,MCO1PinFreq_Value,MCO2PinFreq_Value,PLLCLKFreq_Value,PLLM,PLLN,PLLP,PLLQCLKFreq_Value,PLLSourceVirtual,PWR_Regulator_Voltage_Scale,RCC_MCO1Source,RCC_MCODiv1,RTCFreq_Value,RTCHSEDivFreq_Value,SYSCLKFreq_VALUE,SYSCLKSource,VCOI2SOutputFreq_Value,VCOInputFreq_Value,VCOInputMFreq_Value,VCOOutputFreq_Value,VcooutputI2S
 RCC.LSE_VALUE=32768
 RCC.LSI_VALUE=32000
-RCC.MCO1PinFreq_Value=24000000
-RCC.MCO2PinFreq_Value=48000000
-RCC.PLLCLKFreq_Value=48000000
+RCC.MCO1PinFreq_Value=48000000
+RCC.MCO2PinFreq_Value=96000000
+RCC.PLLCLKFreq_Value=96000000
 RCC.PLLM=8
+RCC.PLLN=384
 RCC.PLLP=RCC_PLLP_DIV4
-RCC.PLLQCLKFreq_Value=48000000
+RCC.PLLQCLKFreq_Value=96000000
 RCC.PLLSourceVirtual=RCC_PLLSOURCE_HSE
-RCC.PWR_Regulator_Voltage_Scale=PWR_REGULATOR_VOLTAGE_SCALE2
+RCC.PWR_Regulator_Voltage_Scale=PWR_REGULATOR_VOLTAGE_SCALE1
 RCC.RCC_MCO1Source=RCC_MCO1SOURCE_PLLCLK
 RCC.RCC_MCODiv1=RCC_MCODIV_2
 RCC.RTCFreq_Value=32000
 RCC.RTCHSEDivFreq_Value=4000000
-RCC.SYSCLKFreq_VALUE=48000000
+RCC.SYSCLKFreq_VALUE=96000000
 RCC.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK
 RCC.VCOI2SOutputFreq_Value=96000000
 RCC.VCOInputFreq_Value=1000000
 RCC.VCOInputMFreq_Value=500000
-RCC.VCOOutputFreq_Value=192000000
+RCC.VCOOutputFreq_Value=384000000
 RCC.VcooutputI2S=48000000
 USART1.IPParameters=VirtualMode
 USART1.VirtualMode=VM_ASYNC
Author	SHA1	Message	Date
crosstyan	f85f6c01c6	feat: Update UART heartbeat message format, adjust UART2 baud rate and oversampling	2025-10-30 12:40:01 +08:00
crosstyan	48bb410179	feat: Enhance UART reception handling with IDLE line detection and hex dump functionality	2025-10-30 12:25:50 +08:00
crosstyan	e13395836f	bad uart tx	2025-10-30 12:01:58 +08:00