UART Problem zwischen ESP32 und STM32

[Jj O. (jj_online)]

Hallo zusammen,

ich habe ein Problem bei der UART Kommunikation zwischen einem ESP32 und 
STM32. Es funktioniert alles soweit bis ich den ESP32 hardresete dann 
sehe ich erstmal ein Framingerror auf RX und im TX einen Shift in der 
Antwort. Sobald ich den STM32 dann hardresete funktioniert wieder alles 
und ich sehe auch die gleiche Ausgabe wie Eingabe. Kann mir jemand 
helfen?

Scheint wohl ein Framing Error zu sein. Wie behebe ich den? Hier mein 
Code:

  #include "main.h"


  #include "ProductMain.h"
  #include <string.h>

  #include "DebugOutput.h"

  #include "GUI.h"



  uint8_t UART7_rxBuffer[2] = {0};
  uint8_t pass1 = 99;

  uint8_t rfidDetected = 0;


  SPI_HandleTypeDef hspi1;

  UART_HandleTypeDef huart7;
  UART_HandleTypeDef huart1;


  void SystemClock_Config(void);
  static void MX_GPIO_Init(void);
  static void MX_SPI1_Init(void);
  static void MX_UART7_Init(void);
  static void MX_USART1_UART_Init(void);

  char spi_buf ='A';

  int main(void)
  {

    HAL_Init();

    SystemClock_Config();


    MX_GPIO_Init();
    MX_SPI1_Init();
    MX_UART7_Init();
    MX_USART1_UART_Init();

    Product_init();


    HAL_UART_Receive_IT (&huart7, UART7_rxBuffer, 2);

    while (1)
    {
      Product_loop(pass1);

    }

  }


  void SystemClock_Config(void)
  {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

   
    __HAL_RCC_PWR_CLK_ENABLE();
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    RCC_OscInitStruct.PLL.PLLM = 16;
    RCC_OscInitStruct.PLL.PLLN = 192;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
    RCC_OscInitStruct.PLL.PLLQ = 4;
    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_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV8;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
    {
    Error_Handler();
    }
    HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_PLLCLK, RCC_MCODIV_1);
  }


  static void MX_SPI1_Init(void)
  {


    hspi1.Instance = SPI1;
    hspi1.Init.Mode = SPI_MODE_MASTER;
    hspi1.Init.Direction = SPI_DIRECTION_2LINES;
    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi1.Init.NSS = SPI_NSS_SOFT;
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi1.Init.CRCPolynomial = 10;
    if (HAL_SPI_Init(&hspi1) != HAL_OK)
    {
    Error_Handler();
    }


  }


  static void MX_UART7_Init(void)
  {


    huart7.Instance = UART7;
    huart7.Init.BaudRate = 9600;
    huart7.Init.WordLength = UART_WORDLENGTH_8B;
    huart7.Init.StopBits = UART_STOPBITS_1;
    huart7.Init.Parity = UART_PARITY_NONE;
    huart7.Init.Mode = UART_MODE_TX_RX;
    huart7.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart7.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart7) != HAL_OK)
    {
    Error_Handler();
    }


  }


  static void MX_USART1_UART_Init(void)
  {


    huart1.Instance = USART1;
    huart1.Init.BaudRate = 9600;
    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_GPIOE_CLK_ENABLE();
    __HAL_RCC_GPIOF_CLK_ENABLE();
    __HAL_RCC_GPIOH_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOD_CLK_ENABLE();

    HAL_GPIO_WritePin(GPIOE, GPIO_PIN_6, GPIO_PIN_RESET);


    HAL_GPIO_WritePin(SPI1_CS_GPIO_Port, SPI1_CS_Pin, GPIO_PIN_RESET);


    HAL_GPIO_WritePin(GPIOD, DISPLAY_RESET_Pin|DISPLAY_DATA_CMD_Pin, GPIO_PIN_RESET);


    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);


    GPIO_InitStruct.Pin = SPI1_CS_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(SPI1_CS_GPIO_Port, &GPIO_InitStruct);


    GPIO_InitStruct.Pin = GPIO_PIN_8;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF0_MCO;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);


    GPIO_InitStruct.Pin = DISPLAY_RESET_Pin|DISPLAY_DATA_CMD_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);

    GPIO_InitStruct.Pin = DISPLAY_BUSY_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(DISPLAY_BUSY_GPIO_Port, &GPIO_InitStruct);

  }



  void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  {

    HAL_UART_Transmit(&huart7, UART7_rxBuffer, 2, 100);
    HAL_UART_Receive_IT(&huart7, UART7_rxBuffer, 2);

  }


  void Error_Handler(void)
  {

    __disable_irq();
    while (1)
    {
    }

  }

  #ifdef  USE_FULL_ASSERT

  void assert_failed(uint8_t *file, uint32_t line)
  {

  }
  #endif /* USE_FULL_ASSERT */

Beste Grüße

[Harry L. (mysth)]

Jj O. schrieb:
> void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
>   {
>     HAL_UART_Transmit(&huart7, UART7_rxBuffer, 2, 100);
>     HAL_UART_Receive_IT(&huart7, UART7_rxBuffer, 2);
>   }

Was soll das?

HAL_UART_Transmit und HAL_UART_Receive haben in dem Callback absolut 
nichts verloren!

Das muß doch knallen.

Beschäftge dich noch mal mit den nicht blockierenden Funktionen!
Das sind die Funktionen, deren Namen auf "_IT" enden - Bsp: 
HAL_UART_Transmit_IT.

Es reicht nicht, die nur einmal vor der mainloop aufzurufen, und man 
sollte sich entscheiden:
Entweder Interrupt-basierend, dann brauchst du die Versionen mit _IT, 
und nur Die, oder via Polling, und dann natürlich gar keine 
Funktionen mit _IT.

Ein Mix geht meist in die Hose.

[Jj O. (jj_online)]

Hast du Recht... ist mir passiert als ich von DMA auf Interrupts 
gewechselt bin. Fixe ich gleiche, habe aber das gleiche Problem mit DMA.

Habe das gleich korrigiert, framing error bleibt aber weiterhin 
bestehen.

[Falk B. (falk)]

Jj O. schrieb:
> Habe das gleich korrigiert, framing error bleibt aber weiterhin
> bestehen.

Ja logisch! Wenn der Controller (Sender) einen RESET macht, geht das 
IO-Pin auf Tristate. Dann macht das Signal was es will, wenn kein 
passender, externer Pull-Up Widerstand existiert.

Außerdem muss eine ROBUSTE Empfangsroutine mit solchen Fehlern klar 
kommen und sich selber wieder syncronisieren. Dazu gibt es spezielle 
Kennzeichen im Datenstrom, Pakete mit Prüfsummen und Timeouts.

[Stefan F. (Gast)]

Der Bootloader gibt ja auch Text mit einer "unerwarteten" Baudrate aus, 
auch das führt zum Framing Fehler.

[Jj O. (jj_online)]

Jup, danke aber wie handle ich das jetzt auf der Seite vom STM?

Bin gerade dabei mit

void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{

  HAL_UART_Abort_IT(&huart7);
}

ne Lösung zu schaffen. Immerhin wird der Framingerror schon detektiert 
aber wie verhindere ich das der Buffer gefüllt wird? Oder denke ich hier 
gerade falsch?

[Beo B. (beobachte)]

Stefan ⛄ F. schrieb:
> Der Bootloader gibt ja auch Text mit einer "unerwarteten" Baudrate aus,
> auch das führt zum Framing Fehler.

🤡 Der esp32 ist 240hz und der stm32 72hz, deshalb geht das nicht! 🤡

[Jj O. (jj_online)]

So scheint's zu funktionieren ^^

void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
  HAL_UART_Abort_IT(&huart7);
  HAL_UART_Receive_IT (&huart7, UART7_rxBuffer, 3);
  HAL_UART_Transmit_IT (&huart7, UART7_rxBuffer, 3);
}

Aber so ganz sauber...

Hat jemand noch ne bessere Idee?

[Harry L. (mysth)]

Jj O. schrieb:
> Hat jemand noch ne bessere Idee?

Schau dir mal den Code im Anhang an.

[Stefan F. (Gast)]

Der HAL UART Treiber Code ist nicht so einfach zu verwenden, wie bei 
Arduino. Vor allem zwingen einem die Festen Puffergrößen dazu, wein 
wenig länger über das Konstrukt nachzudenken.

Hier wurde mal ausführlich diskutiert, wie man mit HAL_UART_xxxx_IT 
einen Ringpuffer umsetzt. Suche mal danach, ich fand den Thread ziemlich 
aufschlussreicht (und hatte danach beschlossen, den UART lieber "zu Fuß" 
zu programmieren, weil mit das mit der HAL unnötig kompliziert vor kam).

[Forist (Gast)]

Jj O. schrieb:
> Scheint wohl ein Framing Error zu sein.

Vor allen Dingen scheint ein ernstes Problem mit einfachstem 
Textverständnis zu bestehen.

Zurück auf Los und lies noch einmal ganz gründlich:

Wichtige Regeln - erst lesen, dann posten!
...
Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

[Harry L. (mysth)]

Stefan ⛄ F. schrieb:
> Vor allem zwingen einem die Festen Puffergrößen
Das ist Unfug!

Stefan ⛄ F. schrieb:
> Hier wurde mal ausführlich diskutiert, wie man mit HAL_UART_xxxx_IT
> einen Ringpuffer umsetzt. Suche mal danach

So kompliziert ist das nicht, und ich hab mehrfach funktionierenden Code 
gezeigt.
Zu letzt hier:

Beitrag "Re: UART Problem zwischen ESP32 und STM32"