Hello everyone,
I am trying to make a very basic uart based data echoing in which my esp32 is master and my stm32 is slave whatever esp3 sends (currently which is hardcoded) should return back to it
here is my esp32 code
HardwareSerial STM(2);
void setup() {
Serial.begin(115200);
STM.begin(115200, SERIAL_8N1, 16, 17); // RX, TX
delay(1000);
Serial.println("ESP32 UART test started");
}
void loop() {
const char *msg = "HELLO STM32\r\n";
STM.print(msg);
Serial.print("TX: ");
Serial.print(msg);
unsigned long t = millis();
while (millis() - t < 200) {
while (STM.available()) {
char c = (char)STM.read();
Serial.write(c);
}
}
delay(1000);
}
and here is my stm32 code
/* USER CODE BEGIN Header */
#include "main.h"
#include <string.h>
/* USER CODE END Header */
UART_HandleTypeDef huart1;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
#define RX_BUF_SIZE 128
static uint8_t rxByte;
static char lineBuf[RX_BUF_SIZE];
static uint16_t lineIdx = 0;
static volatile uint8_t lineReady = 0;
static volatile uint32_t errorCount = 0; /* NEW: counts UART errors */
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART1_UART_Init();
char *startMsg = "STM32 ready, waiting for serial data...\r\n";
HAL_UART_Transmit(&huart1, (uint8_t *)startMsg, strlen(startMsg), HAL_MAX_DELAY);
/* Kick off the first interrupt-driven receive */
HAL_UART_Receive_IT(&huart1, &rxByte, 1);
while (1)
{
if (lineReady)
{
/* Briefly disable the UART IRQ while we copy out the line and
reset state, so an incoming byte can't corrupt lineBuf mid-copy */
char localBuf[RX_BUF_SIZE];
HAL_NVIC_DisableIRQ(USART1_IRQn);
strcpy(localBuf, lineBuf);
lineIdx = 0;
lineReady = 0;
HAL_NVIC_EnableIRQ(USART1_IRQn);
char outBuf[RX_BUF_SIZE + 40];
int len = snprintf(outBuf, sizeof(outBuf), "Received: %s (errors:%lu)\r\n",
localBuf, (unsigned long)errorCount);
HAL_UART_Transmit(&huart1, (uint8_t *)outBuf, len, HAL_MAX_DELAY);
}
}
}
/* Called automatically by HAL every time one byte arrives */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if (huart->Instance == USART1)
{
char c = (char)rxByte;
if (c == '\n' || c == '\r')
{
if (lineIdx > 0) /* ignore empty lines from \r\n pairs */
{
lineBuf[lineIdx] = '\0';
lineReady = 1;
}
}
else if (lineIdx < RX_BUF_SIZE - 1)
{
lineBuf[lineIdx++] = c;
}
/* Re-arm for the next byte */
HAL_UART_Receive_IT(&huart1, &rxByte, 1);
}
}
/* NEW: without this, any framing/noise/overrun error silently kills RX */
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if (huart->Instance == USART1)
{
errorCount++;
__HAL_UART_CLEAR_PEFLAG(huart); /* clear PE/FE/NE/ORE flags */
HAL_UART_Receive_IT(&huart1, &rxByte, 1); /* re-arm */
}
}
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}
static void MX_USART1_UART_Init(void)
{
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();
}
}
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/* PA9 = USART1_TX, PA10 = USART1_RX */
GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF1_USART1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
__HAL_RCC_USART1_CLK_ENABLE();
HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&huart1);
}
void Error_Handler(void)
{
__disable_irq();
while (1) {}
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line) {}
#endif
and here are the serial prints which i am getting
22:35:55.428 -> TX: HELLO STM32
22:35:56.625 -> TX: HELLO STM32
22:35:57.817 -> TX: HELLO STM32
22:35:59.041 -> TX: HELLO STM32
22:36:00.235 -> TX: HELLO STM32
22:36:01.441 -> TX: HELLO STM32
22:36:02.630 -> TX: HELLO STM32
22:36:03.827 -> TX: HELLO STM32
22:36:05.040 -> TX: HELLO STM32
22:36:06.234 -> TX: HELLO STM32
22:36:07.438 -> TX: HELLO STM32
22:36:08.633 -> TX: HELLO STM32
