STM32 HAL USART per interrupt

Habe ich einige Probleme empfangen von Daten über den USART. Was ich eigentlich erreichen möchte ist, dass ich empfangen kann, einen Befehl über USART mit keine bestimmte Länge (maximal mögliche Länge). Also ich benutze die interrupt-routine, um zu überprüfen jedes Zeichen empfangen, aber ich habe irgendwie noch nicht das erreichen können, was ich will. Die routine wird jedes mal aufgerufen, wenn ich einen neuen Charakter, aber irgendwie HAL_UART_Receive_IT(&huart1,rx_data,buff_size_rx) aktualisiert nicht in Echtzeit, dann sehe ich nicht die empfangenen Zeichen wenn ich rx_data[pointer], aber wenige Zeit später ist es in der rx_data Puffer.

Was ich habe, so weit:

int pointer =0;

...

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
    if ( USART1->ISR & UART_IT_TXE) {

    }

    if ( USART1->ISR & UART_IT_RXNE) {
        HAL_UART_Receive_IT(&huart1,rx_data,buff_size_rx);
        if(rx_data[pointer]=='\0') {
              pointer=0;
              readCommand(rx_data);
              clearBuffer(rx_data,buff_size_rx);
        } else {
          pointer++;
          if(pointer>=buff_size_rx) {
              pointer=0;
          }
        }
    }
    /* USER CODE END USART1_IRQn 0 */
    HAL_UART_IRQHandler(&huart1);
    /* USER CODE BEGIN USART1_IRQn 1 */



  /* USER CODE END USART1_IRQn 1 */
}
was ist der Punkt, der das duplizieren des Puffers Umsetzung? BTW you cant call HAL_UART_Receive_IT von hier aus und rufen Sie dann HAL irq-handler, welche Anrufe es wieder. Es tun Nackte Register oder HAL nicht beide. Jedenfalls HAL für einfache Peripherie wie uart?
Was meinst du mit dublicating der Puffer-Implementierung? Ich möchte erreichen, das im HAL, aber ich habe wirklich keine Lösung gefunden noch. DMA wäre schön, aber dort muss ich eine Feste Länge für jeden Befehl, oder verwenden Sie ein Zeitlimit, das nicht unterstützt wird von HAL für ein STM32F303K8T6.
Hal tut es. Sie sollten nichts mit dem buffet, wenn du hal benutzen. Ich würde es umsetzen nackten Widerständler selbst, aber es ist dein code, ohne diese dumme Bibliothek. Wie lange Ihre Nachrichten sind? Wenn kurz es gibt keinen Punkt, der DMA.
Auch die Nachrichten sind nur rund 16 Zeichen. Wenn ich nur HAL_UART_Receive_IT, schreibt er die Zeichen der rx_data Puffer, aber ich habe dann nie sehen, wenn ich erhielt ein null-Zeichen und es wirkt wie ein ring-Puffer, die nur für eine Feste Länge.
Haben Sie einen Blick auf den code, den ich verwenden, um zu erhalten, beliebige GPS-Daten here. Es nutzt HAL aber Verknüpfungen der interrupt. Wenn ich es wieder tun würde ich dump HAL und gehen mit Ebene CMSIS.

InformationsquelleAutor HansPeterLoft | 2017-09-13

  1. 4

    HAL_UART_Receive_IT() ist nicht dazu gedacht, genannt zu werden, aus einem interrupt-handler, der Weg, sondern zu initiieren, erhalten einen festen Anzahl der bytes, die über den interrupt.

    Eine mögliche Problemumgehung überprüfen Sie Ihre Eingabe-Puffer nach HAL_UART_IRQHandler() abgeschlossen ist, D. H. in der /* USER CODE BEGIN USART1_IRQn 1 */ Abschnitt. Wenn ein Befehl verarbeitet wird, können Sie reset pRxBuffPtr und RxXferCount im Griff-Struktur zu Ihren ursprünglichen Werten zu starten, von Beginn des Puffers wieder.

    Andere schrecklich mögliche Abhilfe wäre zu nennen HAL_UART_Receive_IT() mit einer Puffer-Größe von 1, und die Einrichtung eines HAL_UART_RxCpltCallback() handler, überprüft das empfangene byte jedes mal, und fordert HAL_UART_Receive_IT() wieder, wenn nötig.

    Natürlich könnte man es tun, ohne zu HAL, als PeterJ und andere (immer) vorschlagen.

    • Haben Sie bereits umgesetzt pin und interrupt-setup, lassen Sie Sie unverändert zur ersten.
    • Berechnen Sie die UART->BRR Wert nach der Referenz Handbuch, oder kopieren Sie den jeweiligen code von hal.
    • set UART->CR1=USART_CR1_RE|USART_CR1_TE|USART_CR1_UE|USART_CR1_RXNEIE; Jetzt, sind Sie immer unterbricht.
    • In der interrupt-Funktion, Lesen UART->SR in eine temporäre variable ist, und untersuchen Sie es.
    • Lesen UART->DR wenn es ein empfangenes byte warten, tun die Fehlerbehandlung anders (später).
    • Loszuwerden, der rest der HAL Anrufe, wenn das oben funktioniert.

    Interrupt-Antwort und die Bearbeitungszeit ist oft kritische in embedded-Anwendungen, und die HAL nur verschwendet viel.

    Danke, ich werde versuchen Sie die Problemumgehung ersten. Aber wie setzen Sie pRxBuffPtr und RxXferCount? Ich meine die Zeiger braucht eine Adresse?
    aufgerufen wird in der HAL IRQ-handler. Hast du jemals gesehen, wie dieser handler ist implementiert. Mit dieser Funktion wird die phisical Lesen Sie aus der U(S)ART und legt die Daten in den Empfangspuffer. Schreckliche Umsetzung sowieso.
    In die HAL-version? Ich habe ein paar Versionen Rum liegen auf meiner Festplatte, aber HAL_UART_Receive_IT() wird nie genannt in den HAL_UART_IRQHandler() oder sonst irgendwo in der HAL-Bibliotheken. Das eigentliche Lesen der USART->DR registrieren Sie tritt in UART_Receive_IT() (ohne HAL_ Präfix), die als static deklariert, jedoch nicht über das user-Programm.
    setzen Sie an den Anfang (ein Zeiger) und Länge von Ihrem Empfangs-Puffer.

    InformationsquelleAutor berendi

  2. 2

    Den normalen HAL-Bibliothek ist nicht nützlich für die kontinuierliche Rezeption oder Befehle mit unterschiedlicher Länge.

    Wenn Sie die komplette HAL-Paket installiert ist, sehen Sie an den Beispielen für die LowLevel-Schnittstelle. 

    Projects\STM32F411RE-Nucleo\Examples_LL\USART\USART_Communication_Rx_IT_Continuous

    Die wichtigste Sache ist, um Sie usart kontinuierlichen Empfang:

    void Configure_USART(void) {    
    /* (1) Enable GPIO clock and configures the USART pins *********************/

    /* Enable the peripheral clock of GPIO Port */
    USARTx_GPIO_CLK_ENABLE();

    /* Configure Tx Pin as : Alternate function, High Speed, Push pull, Pull up */
    LL_GPIO_SetPinMode(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_MODE_ALTERNATE);
    USARTx_SET_TX_GPIO_AF();
    LL_GPIO_SetPinSpeed(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_SPEED_FREQ_HIGH);
    LL_GPIO_SetPinOutputType(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_OUTPUT_PUSHPULL);
    LL_GPIO_SetPinPull(USARTx_TX_GPIO_PORT, USARTx_TX_PIN, LL_GPIO_PULL_UP);

    /* Configure Rx Pin as : Alternate function, High Speed, Push pull, Pull up */
    LL_GPIO_SetPinMode(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_MODE_ALTERNATE);
    USARTx_SET_RX_GPIO_AF();
    LL_GPIO_SetPinSpeed(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_SPEED_FREQ_HIGH);
    LL_GPIO_SetPinOutputType(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_OUTPUT_PUSHPULL);
    LL_GPIO_SetPinPull(USARTx_RX_GPIO_PORT, USARTx_RX_PIN, LL_GPIO_PULL_UP);

    /* (2) NVIC Configuration for USART interrupts */
    /*  - Set priority for USARTx_IRQn */
    /*  - Enable USARTx_IRQn */
    NVIC_SetPriority(USARTx_IRQn, 0);  
    NVIC_EnableIRQ(USARTx_IRQn);

    /* (3) Enable USART peripheral clock and clock source ***********************/
    USARTx_CLK_ENABLE();

    /* (4) Configure USART functional parameters ********************************/
    /* TX/RX direction */
    LL_USART_SetTransferDirection(USARTx_INSTANCE, LL_USART_DIRECTION_TX_RX);

    /* 8 data bit, 1 start bit, 1 stop bit, no parity */
    LL_USART_ConfigCharacter(USARTx_INSTANCE, LL_USART_DATAWIDTH_8B, LL_USART_PARITY_NONE, LL_USART_STOPBITS_1);

    /* No Hardware Flow control */
    /* Reset value is LL_USART_HWCONTROL_NONE */
    //LL_USART_SetHWFlowCtrl(USARTx_INSTANCE, LL_USART_HWCONTROL_NONE);

    /* Oversampling by 16 */
    /* Reset value is LL_USART_OVERSAMPLING_16 */
    //LL_USART_SetOverSampling(USARTx_INSTANCE, LL_USART_OVERSAMPLING_16);

    /* Set Baudrate to 115200 using APB frequency set to 100000000/APB_Div Hz */
    /* Frequency available for USART peripheral can also be calculated through LL RCC macro */
    /* Ex :
        Periphclk = LL_RCC_GetUSARTClockFreq(Instance); or 
        LL_RCC_GetUARTClockFreq(Instance); depending on USART/UART instance

        In this example, Peripheral Clock is expected to be equal to 
        100000000/APB_Div Hz => equal to SystemCoreClock/APB_Div
    */
    LL_USART_SetBaudRate(USARTx_INSTANCE, SystemCoreClock/APB_Div, LL_USART_OVERSAMPLING_16, 115200); 

    /* (5) Enable USART *********************************************************/
    LL_USART_Enable(USARTx_INSTANCE);
}

    Den USART-ES-Handler Aussehen sollte

    void USARTx_IRQHandler(void)
{
  /* Check RXNE flag value in SR register */
  if(LL_USART_IsActiveFlag_RXNE(USARTx_INSTANCE) && LL_USART_IsEnabledIT_RXNE(USARTx_INSTANCE))
  {
    /* RXNE flag will be cleared by reading of DR register (done in call) */
    /* Call function in charge of handling Character reception */
    USART_CharReception_Callback();
  }
  else
  {
    /* Call Error function */
    Error_Callback();
  }
}

    Die Letzte Sache, die Sie zum einrichten der Callback -

    void USART_CharReception_Callback(void);

    Wo könnte man die bytes in einen Puffer und Griff es in der main-loop oder wo Sie wollen.

    InformationsquelleAutor theSealion

Schreibe einen Kommentar