STM32F4 UART Problem, Interrupt Polling LOCK

[Marcus (Gast)]

Hallo Leute,
ich programmiere zur Zeit ein STM32F4 Discovery Board, mit CubeMX und 
HAL Treibern.
Folgendes Problem:
Ich sende im Sekunden-Takt zyklisch Daten über HAL_UART_TRANSMIT().
Empfangen tue ich mittels eines Interrupts. Jetzt folgendes Problem:
Wenn ich am senden bin und gleichzeitig was empfange, dann hängt sich 
der Uart auf. Also die Senderichtung geht noch, aber Empfangen tue ich 
nichts mehr.

Ich habe bereits rausgefunden das im Treiber selber ein HAL_LOCK 
stattfindet, der den Uart daran hindert, sachen über den Interrupt 
Eingang zu empfangen.

Ich bekomme es nicht hin dieses Problem zu lösen. Hat jemand einen 
Ansatz oder dieses Problem auch schon gehabt?

HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
  uint16_t* tmp;
  uint32_t tickstart = 0U;
  
  /* Check that a Tx process is not already ongoing */
  if(huart->gState == HAL_UART_STATE_READY) 
  {
    if((pData == NULL ) || (Size == 0U)) 
    {
      return  HAL_ERROR;
    }
    
    /* Process Locked */
    __HAL_LOCK(huart);
    
    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->gState = HAL_UART_STATE_BUSY_TX;
  
    /* Init tickstart for timeout managment */
    tickstart = HAL_GetTick();

    huart->TxXferSize = Size;
    huart->TxXferCount = Size;
    while(huart->TxXferCount > 0U)
    {
      huart->TxXferCount--;
      if(huart->Init.WordLength == UART_WORDLENGTH_9B)
      {
        if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
        { 
          return HAL_TIMEOUT;
        }
        tmp = (uint16_t*) pData;
        huart->Instance->DR = (*tmp & (uint16_t)0x01FFU);
        if(huart->Init.Parity == UART_PARITY_NONE)
        {
          pData +=2U;
        }
        else
        { 
          pData +=1U;
        }
      } 
      else
      {
        if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
        {
          return HAL_TIMEOUT;
        }
        huart->Instance->DR = (*pData++ & (uint8_t)0xFFU);
      } 
    }
    
    if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    { 
      return HAL_TIMEOUT;
    }
    
    /* At end of Tx process, restore huart->gState to Ready */
      huart->gState = HAL_UART_STATE_READY;
    
    /* Process Unlocked */
    __HAL_UNLOCK(huart);
    
    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  /* Check that a Rx process is not already ongoing */ 
  if(huart->RxState == HAL_UART_STATE_READY)
  {
    if((pData == NULL ) || (Size == 0U)) 
    {
      return HAL_ERROR;
    }
    
    /* Process Locked */
    __HAL_LOCK(huart);
    
    huart->pRxBuffPtr = pData;
    huart->RxXferSize = Size;
    huart->RxXferCount = Size;
    
    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->RxState = HAL_UART_STATE_BUSY_RX;
    
    /* Process Unlocked */
    __HAL_UNLOCK(huart);
        
    /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    SET_BIT(huart->Instance->CR3, USART_CR3_EIE);

    /* Enable the UART Parity Error and Data Register not empty Interrupts */
    SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    
    return HAL_OK;
  }
  else
  {
    return HAL_BUSY; 
  }
}

#define __HAL_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = 0U)

#if (USE_RTOS == 1)
  /* Reserved for future use */
  #error "USE_RTOS should be 0 in the current HAL release"
#else
  #define __HAL_LOCK(__HANDLE__)                                           \
                                do{                                        \
                                    if((__HANDLE__)->Lock == HAL_LOCKED)   \
                                    {                                      \
                                       return HAL_BUSY;                    \
                                    }                                      \
                                    else                                   \
                                    {                                      \
                                       (__HANDLE__)->Lock = HAL_LOCKED;    \
                                    }                                      \
                                  }while (0)

  #define __HAL_UNLOCK(__HANDLE__)                                          \
                                  do{                                       \
                                      (__HANDLE__)->Lock = HAL_UNLOCKED;    \
                                    }while (0)
#endif /* USE_RTOS */

Gruß

[STM Apprentice (Gast)]

Einfach schrecklich dieses HAL Zeugs, ich wills mir gar nicht
anschauen.

Ewig lange Bezeichner für Typen und Aufrufe, Overhead an
allen Ecken und Enden.

Meine selbstgeschriebenen Sourcen für interrupt-betriebenen
UART funktionieren ohne Probleme, und das ganz ohne HAL.

[Marcus (Gast)]

Hallo,
danke für deine Antwort, hilft mir aber zunächst leider nicht.

[STM Apprentice (Gast)]

Marcus schrieb:
> hilft mir aber zunächst leider nicht.

War mir schon klar, aber vielleicht hilft es für die
Zukunft zu der Einsicht einen anderen Ansatz zu wählen.

[Marcus (Gast)]

Das stimmt wohl :). Ich hänge nur leider schon etwas länger an dem 
Problem, und bin auch kein Profi, was das Programmieren angeht. Wäre 
nett, wenn sich jemand meiner Annehmen könnte.
Gruß Marcus

[me (Gast)]

Hi, wie sieht denn deine Rx IRS aus.
Was hat du in der Funktion "void USART2_IRQHandler(void)" drinnenstehen?

Ich benutze auch den STM32F4 seit kurzem allerdings erst.
Ich sende und empfange ebenfalls, allerdings nicht gleichzeitig.
Es wird bei mir gesendet, Gegenstelle antwortet darauf und so weiter.

Bisher läuft das soweit ohne Probleme.

[Marcus (Gast)]

Hi!
Also meine Routinge sieht wie folgt aus:

void USART3_IRQHandler(void)
{
  /* USER CODE BEGIN USART3_IRQn 0 */

  /* USER CODE END USART3_IRQn 0 */
  HAL_UART_IRQHandler(&huart3);
  /* USER CODE BEGIN USART3_IRQn 1 */
  HAL_UART_Receive_IT(&huart3, &bufftemp, 1);
  /* USER CODE END USART3_IRQn 1 */
}

[Jim M. (turboj)]

> Ich bekomme es nicht hin dieses Problem zu lösen. Hat jemand einen
Ansatz oder dieses Problem auch schon gehabt?

HAL_UART_Receive_IT ist eindeutig für den Aufruf aus main() gedacht und 
funktioniert so nicht im UART Interrupt.

Entweder Du baust Dein Programm um, so das HAL_UART_Receive_IT nicht 
mehr im Interrupt benutzt wird oder Du musst Dir eine Receive Funktion 
passen selbst schreiben.

Ich überblicke jetzt nicht ob es ausreicht die __HAL_LOCK/__HAL_UNLOCK 
zu entfernen.

[me (Gast)]

HAL_UART_Receive_IT

Passt da meiner Meinung nach schon.
Das musste ich da auch rein nehmen, ansonsten wird einmal empfangen und 
dann nicht mehr.

[W.S. (Gast)]

Marcus schrieb:
> Ich hänge nur leider schon etwas länger an dem
> Problem, und bin auch kein Profi, was das Programmieren angeht. Wäre
> nett, wenn sich jemand meiner Annehmen könnte.

Und wie stellst du dir das vor? Dir nen fertigen Code zu liefern, über 
den du nicht nachzudenken brauchst?

Also erstens: Denke nach.. und zwar, wie man das gleichzeitige Senden 
und Empfangen denn organisieren könnte - Hinweis: zwei Ringpuffer.

Zweitens: suche hier im Forum mal nach einschlägigen Beiträgen von mir 
und deren Anhängen. Da ist nämlich öfters mal was fertiges dabei - 
allerdings nicht exakt für deinen Controller. Aus sowas kannst du aber 
lernen, wie man sowas macht.

Drittens: gib dir Mühe.

W.S.

[Christopher J. (christopher_j23)]

me schrieb:
> HAL_UART_Receive_IT
>
> Passt da meiner Meinung nach schon.

Das glaube ich eher weniger.


me schrieb:
> Das musste ich da auch rein nehmen, ansonsten wird einmal empfangen und
> dann nicht mehr.

Das ist das typische Trial-and-Error, was ab und an dazu führt, das 
etwas in 95% der Fälle funktioniert.

Mein Gott, man muss doch nur in den Quelltext schauen 
(stm32fxxx_hal_uart.c):

/*
...
    (#) Non-Blocking mode API's with Interrupt are :
        (++) HAL_UART_Transmit_IT()
        (++) HAL_UART_Receive_IT()
        (++) HAL_UART_IRQHandler()

...
    (#) Non-Blocking mode transfers could be aborted using Abort API's :
        (++) HAL_UART_Abort()
        (++) HAL_UART_AbortTransmit()
        (++) HAL_UART_AbortReceive()
        (++) HAL_UART_Abort_IT()
        (++) HAL_UART_AbortTransmit_IT()
        (++) HAL_UART_AbortReceive_IT()
...
*/

Sowie einen Blick in den Header stm32fxxx_hal_uart.h:

// ...
HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
// ...
/* Transfer Abort functions */
HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);

Schaut man dann noch in den Code von HAL_UART_IRQHandler() stellt man 
fest, dass von dort aus die Funktionen UART_Receive_IT() und 
UART_Transmit_IT() (jeweils ohne HAL_-Präfix !) aufgerufen werden und 
dafür sorgen das die Daten in bzw. aus pData (d.h. RX- bzw. TX-Buffer) 
empfangen bzw. gesendet werden. Logischerweise sollte der RX-Buffer 
größer sein als die Menge an Daten die man erwartet. Ist der RX-Buffer 
aber nicht voll, kann man per HAL_UART_Receive_IT keine neue Transaktion 
starten. Man muss zunächst die bestehende Transaktion per 
HAL_UART_AbortReceive_IT() anhalten. Die Antwort warum das so ist findet 
sich direkt in der ersten Zeile der HAL_UART_Receive_IT():

HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  /* Check that a Rx process is not already ongoing */ 
  if(huart->RxState == HAL_UART_STATE_READY)
  {
  //... Setup von Receive-Buffer, etc.
  }
  else
  {
    return HAL_BUSY; 
  }
}

Also zusammengefasst:
HAL_UART_Receive_IT(), HAL_UART_Transmit_IT() sowie 
HAL_UART_AbortReceive() gehören in deine main(). HAL_UART_IRQHandler() 
dagegen gehört in die ISR und sorgt dafür, dass HAL_UART_Receive_IT() 
sowie HAL_UART_Transmit_IT() überhaupt funktionieren können. 
HAL_UART_Receive_IT() funktioniert aber nur einmal, wenn der Buffer 
nicht vor dem zweiten Aufruf voll war oder es durch 
HAL_UART_AbortReceive() händisch gestoppt wurde.

[Marcus (Gast)]

Danke Christopher!
@W.S. schreib einfach nichts wenn du nicht helfen willst. Gerade weil 
man was lernen will schreibt man in dieses Forum. Bei jedem 2. Thread 
findet man solche Internet Helden wie dich. Hauptsache du gibst deinen 
Senf dazu.