Not Receiving UART message from STM32WL5M to Laptop

[Dicko]

Hi there, I have an B-WL5M-SUBG1 evaluation board which uses the STM32WL5M module.

I am having problems with the STM32 receiving a message I am sending it from my laptop via python.

I connect between the stm32 and the laptop via an RS422/485 converter. I've used the converter many times before to read print statements from the stm32.

Here is the stm32 code I am using:

#include "main.h"
#include "stm32wlxx_hal.h"
#include <string.h>
#include <stdio.h>

/* Private variables */
UART_HandleTypeDef huart2;
uint8_t rx_buffer[4];  // Buffer for received data
volatile uint8_t data_received = 0; // Flag for data reception

/* Function prototypes */
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
void Error_Handler(void);
void check_uart_errors(void);

int main(void)
{
    uint8_t tx_ready[] = "READY\r\n";

    /* Initialize system */
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();

    /* Reset UART2 before use */
    __HAL_RCC_USART2_FORCE_RESET();
    HAL_Delay(10);
    __HAL_RCC_USART2_RELEASE_RESET();

    MX_USART2_UART_Init();

    /* Transmit READY message */
    if (HAL_UART_Transmit(&huart2, tx_ready, sizeof(tx_ready) - 1, 300) != HAL_OK)
    {
        Error_Handler();
    }

    HAL_Delay(10); // Prevent issues

    /* Clear UART RX buffer and start receiving */
    __HAL_UART_FLUSH_DRREGISTER(&huart2);
    memset(rx_buffer, 0, sizeof(rx_buffer));

    if (HAL_UART_Receive_IT(&huart2, rx_buffer, sizeof(rx_buffer)) != HAL_OK)
    {
        Error_Handler();
    }

    while (1)
    {
        if (data_received)
        {
            data_received = 0; // Reset flag

            /* Debug: Print received bytes */
            char debug_msg[50];
            sprintf(debug_msg, "RX CALLBACK: %02X %02X %02X %02X\r\n",
                    rx_buffer[0], rx_buffer[1], rx_buffer[2], rx_buffer[3]);
            HAL_UART_Transmit(&huart2, (uint8_t *)debug_msg, strlen(debug_msg), 300);
            HAL_Delay(10);

            /* Echo back the received 4 bytes */
            if (HAL_UART_Transmit(&huart2, rx_buffer, 4, 300) != HAL_OK)
            {
                Error_Handler();
            }

            /* Restart reception */
            memset(rx_buffer, 0, sizeof(rx_buffer));
            if (HAL_UART_Receive_IT(&huart2, rx_buffer, sizeof(rx_buffer)) != HAL_OK)
            {
                Error_Handler();
            }

            check_uart_errors(); // Check for errors after transmission
        }
    }
}

/**
  * @brief System Clock Configuration
  */
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
    RCC_OscInitStruct.MSIState = RCC_MSI_ON;
    RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
    RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;  // 4 MHz
    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_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
    {
        Error_Handler();
    }
}

/**
  * @brief USART2 Initialization Function
  */
static void MX_USART2_UART_Init(void)
{
    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;
    huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
    huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    if (HAL_UART_Init(&huart2) != HAL_OK)
    {
        Error_Handler();
    }
}

/**
  * @brief UART RX Complete Callback
  */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART2)
    {
        data_received = 1; // Set flag to process received data
    }
}

/**
  * @brief Check UART Errors
  */
void check_uart_errors(void)
{
    uint32_t error = HAL_UART_GetError(&huart2);
    if (error != HAL_UART_ERROR_NONE)
    {
        char error_msg[50];
        sprintf(error_msg, "UART ERROR: 0x%lX\r\n", error);
        HAL_UART_Transmit(&huart2, (uint8_t *)error_msg, strlen(error_msg), 300);
    }
}

/**
  * @brief GPIO Initialization Function
  */
static void MX_GPIO_Init(void)
{
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    /* Configure PA2 and PA3 as Alternate Function (AF7) for USART2 */
    GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

/**
  * @brief  Error Handler.
  */
void Error_Handler(void)
{
    __disable_irq();
    while (1)
    {
    }
}

View more

 My python code is this:

#!/usr/bin/env python3
import serial
import time

def main():
    ser = serial.Serial(
        port="COM4",
        baudrate=115200,
        bytesize=8,
        parity='N',
        stopbits=1,
        timeout=2,
        xonxoff=False,
        rtscts=False,
        dsrdtr=False
    )

    print(f"Opened COM4 at {ser.baudrate} baud.")

    # Wait for READY message
    start_time = time.time()
    ready_received = False
    while time.time() - start_time < 5:
        line = ser.readline()
        if line:
            decoded = line.decode(errors="replace")
            print("MCU says:", decoded, end='')
            if "READY" in decoded:
                ready_received = True
                break
    if not ready_received:
        print("No READY message received from MCU.")
        ser.close()
        return

    # Clear UART buffer before sending
    ser.reset_input_buffer()
    time.sleep(0.1)

    # Send 4 bytes
    test_msg = b"DATA"
    print("\nSending:", test_msg)
    ser.write(test_msg)
    ser.flush()

    # Wait for response with timeout
    timeout = time.time() + 5
    while time.time() < timeout:
        line = ser.readline()
        if line.startswith(b"RX CALLBACK: "):
            print("MCU Debug:", line.decode(errors="replace").strip())
            continue
        elif len(line) == 4:
            print("Received:", line)
            break
    else:
        print("Error: No response received from STM32.")

    ser.close()
    print("Done.")

if __name__ == "__main__":
    main()

View more

and my output from python is:

Opened COM4 at 115200 baud.
MCU says: READY

Sending: b'DATA'
Error: No response received from STM32.
Done.

Does anybody have any ideas on what the problem is here and how I could fix it. Any help would be greatly appreciated.

Thank you.

[Dicko]

Hi Andrew, I’ll draw a schematic tomorrow. But my setup is as follows:

I have the B-WL5M-SUBG1 powered by a 5V bench PSU.

i connect the B-WL5M-SUBG1 to an MB1440B board to access the tx and rx pins easier. 
I connect the Tx and Rx pins to the T+ and T- pins of the converter. I’ve used this setup numerous times to read sensor data from the B-WL5M-SUBG1. 

I can the USART2 pins (as usual) set to asynchronous mode. 

Pictures below. 

[Dicko]

Hi Andrew,

There was no particular reason on using the RS422/485 converter other than to see the messages from the STM32 on my Laptop via Putty or my Python program. I've used it in the past on other microcontrollers and used it with the STM32 to view sensor data on my Laptop.

A schematic would show just what I have in the Photos above really.

I've attached the schematic for the B-WL5M-SUBG1, again I am using USART2, which are the Tx and Rx pins on the 

[Dicko]

The pinout of the converter.

[Dicko]

Hey folks, just wondering if anyone from ST is able to replicate this issue? I’m still not having any luck. 

[Dicko]

I enabled the NVIC for USART 2 and now my output is:

Opened COM4 at 115200 baud.
MCU says: READY

Sending: b'DATA'
MCU Debug: RX CALLBACK: 57 5D F5 01
Received: b'W]\xf5\x01'
Done.

But the received data doesn't look right. Here are the traces from my scope too (attached).

[Andrew Neil]

---

@Dicko wrote:

the received data doesn't look right. Here are the traces from my scope too (attached).

---

That generally means that your baud rate is wrong:

https://learn.sparkfun.com/tutorials/serial-communication/all#:~:text=If%20all%20the%20receiving%20device%20sees%20on%20its%20receive%20line%20is%20garbage%2C%20check%20to%20make%20sure%20the%20baud%20rates%20match%20up.

[Dicko]

I’m wondering whether it’s because the STM32 uses 3.3V logic levels whilst the adapter uses 5V. 

[Dicko]

Is there a way to escalate this to ST? I'm not getting anywhere at all.

[Andrew Neil]

Have you tried it with a plain UART-to-USB converter?

To raise a direct support case, see: https://ols.st.com/s/

Or contact your FAE or Distributor: https://www.st.com/content/st_com/en/contact-us.html

[Dicko]

Thanks Andrew, yeah I made a case earlier today. I’ll report back if they come back with a solution.