STM32 - UART Ausgabe - Wie richtig?

[Viktor S. (viktor_s)]

Sehr geehrte Forum Mitglieder,

ich setze mich gerade mit STM32 und UART auseinander.
Dazu habe ich mir eine kleine Schrittkette gebaut.

Die Schrittkette scheint viel zu schnell abzulaufen, sodass die
UART-Ausgaben nicht gesendet werden. Man müsste jeder Ausgabe Zeit geben
aber das Programm  nicht anhalten.

Gibt es eine Abfrage ob die UART-Ausgabe abgeschlossen ist?

Frage: Wie macht Ihr die UART-Ausgaben?

/* 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 ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "string.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */


#define RxBuf_Size 10
#define MainBuf_Size 20

uint8_t RxBuf[RxBuf_Size];
uint8_t MainBuf[MainBuf_Size];

void HAL_UARTEx_RxEventCallback( UART_HandleTypeDef *huart, uint16_t Size ){

  //if(huart -> Instance == USART2 ){
    for(int i=0;i < sizeof(MainBuf) ; i++){
        MainBuf[i] = '0';
    }

    memcpy ( MainBuf, RxBuf, Size );

    for(int i=0;i < Size ; i++){
      RxBuf[i] = '0';
    }
      HAL_UARTEx_ReceiveToIdle_DMA(&huart2, RxBuf, RxBuf_Size);
      __HAL_DMA_DISABLE_IT(&hdma_usart2_rx,DMA_IT_HT);

  //}

}


/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  int flag =0;
  int flag2 =0;
  int iState =0;


  uint32_t t1;
  uint32_t t2;
  uint32_t dt;


  /* 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_DMA_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */


  HAL_UARTEx_ReceiveToIdle_DMA(&huart2, RxBuf, RxBuf_Size);


    __HAL_DMA_DISABLE_IT(&hdma_usart2_rx,DMA_IT_HT);

    HAL_UART_Transmit_DMA(&huart2, "Hallo", 5);


  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

    switch(iState){

    case 0:

      HAL_UART_Transmit_DMA(&huart2, "Welcome! \n\r", 15);

      iState = 5;

      break;

    case 5:

      HAL_UART_Transmit_DMA(&huart2, "Step:5 \n\r", 15);

      iState = 10;

      break;

    case 10:

      t1 = HAL_GetTick();

      iState = 15;

      break;

    case 15:



      HAL_UART_Transmit_DMA(&huart2, "Waiting... \n\r", 15);


      iState = 20;

      break;

    case 20:


      t2 = HAL_GetTick();

      dt = t2-t1;

      if(dt > 10000){
        iState = 25;
      }

      break;

    case 25:



      HAL_UART_Transmit_DMA(&huart2, "Choose >1< \n\r", 15);
      //HAL_UART_Transmit(&huart2, "Choose >1< \n\r", 15, 1000);

      iState = 30;
      break;

    case 30:

      //HAL_UART_Transmit_DMA(&huart2, "Step:3 \n\r", 15);

      if(MainBuf[0] == '1'){
        iState = 300;
      }

      //xUartRcvDatProcessed = 1;

      break;
    case 300:
      HAL_UART_Transmit_DMA(&huart2, "Step:300 \n\r", 15);

      //HAL_UART_Transmit(&huart2, "Works! \n\r", 15,1000);

      iState = 500;

      break;

    case 500:

      HAL_UART_Transmit_DMA(&huart2, "Step:500 \n\r", 15);

      iState = 501;

      break;

    case 501:
      break;

    }



    /* 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};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48;
  RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI48;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
  PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @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 = 9600;
  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.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel4_5_6_7_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel4_5_6_7_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel4_5_6_7_IRQn);

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

[Helmut -. (dc3yc)]

Lies bitte die "Wichtige Regeln - erst lesen, dann posten!", bevor du so 
einen Scheiß schreibst!

[Wastl (hartundweichware)]

Viktor S. schrieb:
> Sehr geehrte Forum Mitglieder,
>
> ich setze mich gerade mit STM32 und UART auseinander.

Fuck!

Setze dich erst einmal mit den Regeln hier im Forum auseinander!

[Harry L. (mysth)]

Beitrag "Re: [STM32/HAL] simples U(S)ART-Library"

[Peter (pittyj)]

Ich verzichte auf DMA, und nehme die normale Interrupt Variante.
Ich nehme auch den Code, den die STM IDE automatisch erzeugt, und es 
lief auf Anhieb.
Durch deinen Code steige ich nicht durch. Man hätte die Leerzeilen und 
automatisch generierten Kommentare löschen können, damit man 'deine 
Eigenleistung' überhaupt erkennt.
Bei so einem Code hat keiner mehr Lust sich den überhaupt anzuschauen.

[J. S. (jojos)]

es ist egal ob man die Interrupt oder DMA Variante nimmt, es bleibt das 
Problem das die Funktion  HAL_UART_Transmit_xx erst wieder ausgeführt 
wird wenn der verwendete UART frei ist. D.h. sie liefert sofort den 
Fehler HAL_BUSY, blöderweise auch ohne ein Timeout abzuwarten.
Es fehlt also ein Ausgabepuffer und das würde durch den Code von Harry 
gelöst. Oder man verwendet das gepufferte stdio über printf, dazu 
braucht es nur eine Funktion _write() die den String über den 
gewünschten UART ausgibt.

[Viktor S. (viktor_s)]

Sehr geehrte Forum-Mitglieder,

erstmal vorweg: an Helmut und Wastl: Den Hinweis, dass man einen langen 
Code
nicht senden soll, sieht man nicht auf Anhieb.
Ich werde den Hinweis in Zukunft beachten, so wie Ihr in Zukunft auf 
Euere Sprache achten müsst. Mit so einer Art kommt man nicht weiter! 
Geht ihr auch so mit Eueren Kollegen und anderen Mitmenschen um?

Vielen Dank an die Mitglieder, welche meine Frage ernst genommen haben.

Zurück zum Thema:
Wie J.S. schreibt, wäre die Lösung auf den UART zu warten und erst 
wieder eine Ausgabe zu liefern, wenn der UART bereit dafür ist.

Kann mir Jemand sagen, wie man den aktuellen Zustand des verwendeten 
UART abfragen kann? Vielleicht einen Hinweis auf eine Doku geben. Bis 
jetzt habe ich nichts außer "HAL_UART_TxCpltCallback" gefunden.

[J. S. (jojos)]

HAL_UART_Transmit liefert busy zurück, das könnte man auswerten. Aber es 
blockiert ja den Ablauf, ich würde das nicht so machen.

[Harry L. (mysth)]

Viktor S. schrieb:
> Vielleicht einen Hinweis auf eine Doku geben.

https://www.st.com/resource/en/user_manual/um1725-description-of-stm32f4-hal-and-lowlayer-drivers-stmicroelectronics.pdf

Wie man das alles benutzt, siehst du in meinem oben verlinkten Code.

[A. F. (chefdesigner)]

Wastl schrieb:
> Fuck!
>
> Setze dich erst einmal mit den Regeln hier im Forum auseinander!

Das erste Wort hättest du dir sparen können :-)
Dann wäre deine Kritik auch besser verarbeitbar :-)

[Wastl (hartundweichware)]

Viktor S. schrieb:
> Wie J.S. schreibt, wäre die Lösung auf den UART zu warten und erst
> wieder eine Ausgabe zu liefern, wenn der UART bereit dafür ist.
>
> Kann mir Jemand sagen, wie man den aktuellen Zustand des verwendeten
> UART abfragen kann? Vielleicht einen Hinweis auf eine Doku geben. Bis
> jetzt habe ich nichts außer "HAL_UART_TxCpltCallback" gefunden.

Das "Geheimnis" ist: Low-Level Library verwenden. Man kann es gar
nicht deutlich genug sagen: das ist ein wahrer Schatz der
harwarenahen Programmierung (woanders habe ich so etwas noch
nie gesehen). Alles Zugriffsmakros die es erlauben auf Register-
Ebene zu programmieren ohne jemals ein Register oder ein Register-
Bit mit Namen zu kennen. Macht ein bisschen mehr Arbeit als das
HAL Zeugs aber man wird mit Code belohnt der so arbeitet wie
man sich es vorstellt. Natürlich gibt es auch in der LL einige
benötigte Funktionen die einem das Leben leicht machen, aber
die Zugriffsmakros sind schon das Allerwichtigste. Im Prinzip
könnte man wohl auch die gesamte Hardware-Initialisierung
damit bewerkstelligen.

[Steve van de Grens (roehrmond)]

Viktor S. schrieb:
> Den Hinweis, dass man einen langen Code nicht
> senden soll, sieht man nicht auf Anhieb.

Das ist eine sehr faule Ausrede.

[Harry L. (mysth)]

Wastl schrieb:
> Das "Geheimnis" ist: Low-Level Library verwenden.

Kann man machen, ist aber in den allermeisten Fällen vollkommen unnötig.
Das braucht man eigentlich nur auf sehr, sehr kleinen MCUs, wo man um 
jedes Byte kämpfen muß.

HAL ist komplexer, aber auch einfacher anzuwenden. (wenn man es einmal 
verstanden hat)
Auf die Ausführungs-Geschwindigkeit hat das nahezu keinen Einfluss und 
die Einsparungen bei der Größe des Binary sind sehr überschaubar.

[Helmut -. (dc3yc)]

Viktor S. schrieb:
> Den Hinweis, dass man einen langen
> Code
> nicht senden soll, sieht man nicht auf Anhieb.

Dann als Tip, bevor du noch mehr Fehler programmierst, weil du was nicht 
lesen kannst: Gehe mal zum Optiker und lasse dir eine Brille verpassen. 
Ich jedenfalls habe keine Lust, dein Programm zu lesen, weil ich mit dem 
Scrollen nicht nachkomme.

[Klaus (feelfree)]

Helmut -. schrieb:
> Ich jedenfalls habe keine Lust, dein Programm zu lesen, weil ich mit dem
> Scrollen nicht nachkomme.

Prima, jeder unfreundliche Meckerer weniger tut dem Forum gut.

[Viktor S. (viktor_s)]

Wie gesagt, werde in Zukunft die Regeln mehr beachten.
Ich wollte auf keinen Fall unfreundlich wirken.

[Viktor S. (viktor_s)]

Ich bin nochmal ein Schritt zurück gegangen und habe
einfach ein Projekt erstellt, wo ich per UART Texte
in einer Schrittkette ausgebe.

Am Anfang mache ich eine Pause von 5sek, bevor der nächste
Text ausgegeben wird.
Zum Schluss gebe ich die Texte per UART ohne zeitlicher
Verzögerung aus.

Das Seltsame ist, dass bei  den ersten Ausgaben immer
eine "Sta"-Zeichenkette davor geschrieben wird.
Bei den letzten Ausgaben jedoch nicht.

Habe von der Ausgabe ein Video gemacht:

https://streamable.com/fhjswh

Habt Ihr sowas erlebt? Warum passiert das?
Ich versuche mich  erstmal mit der HAL irgendwie auseinander zu setzen.

[Rick (rick)]

Viktor S. schrieb:
> Das Seltsame ist, dass bei  den ersten Ausgaben immer
> eine "Sta"-Zeichenkette davor geschrieben wird.
> Bei den letzten Ausgaben jedoch nicht.
Dein Programm läuft zweimal. Nach einem kurzen Moment kommt der Debugger 
und macht einen Reset. Da hat er gerade die ersten drei Zeichen 
geschafft.
Mach mal die Pause etwas länger oder schreib drei Leerzeichen und einen 
Zeilenumbruch als Erstes...

[Viktor S. (viktor_s)]

Hallo Rick, ich habe deine Anweisungen befolgt und ein neues Video 
aufgezeichnet.

https://streamable.com/3jjsfy

Irgendetwas stimmt da nicht.
Die Zeichenkette "Sta" kommt ein paar Mal.

[Rick (rick)]

Da ich die HAL nicht nutze (zu abstrakt), kann ich zu deren Verwendung 
nur wenig sagen, aber mir ist aufgefallen das bei dir der dritte 
Parameter (Size) bei HAL_UART_Transmit nicht an die Datenlänge angepasst 
wird...

[Viktor S. (viktor_s)]

Habe für den auszugebenden String eine feste Größe
von 5 Zeichen zugeordnet.

Vor jeder Ausgabe leere ich den String.

Nun scheint es zu funktionieren.

https://streamable.com/so96wr