STM32F031K6 HAL UART Interrupts Problem

Eine grundlegende UART-Initialisierung mit Interrupts, die HAL verwenden, sieht in etwa so aus wie unten. Ich möchte die Parameter nicht beschreiben, da sie ziemlich offensichtlich sind. Es ist eine tatsächliche Pin-Konfiguration und die UART-Peripheriekonfiguration. HAL_UART_MspInitwird von angerufen HAL_UART_Init, um es zu benutzen, müssen Sie nur anrufen MX_USART1_UART_Init.

#include "stm32f0xx_hal.h"

UART_HandleTypeDef huart1;

void MX_USART1_UART_Init(void)
{
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  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;
  huart1.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&huart1);
}

void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  if(huart->Instance==USART1)
  {
    __USART1_CLK_ENABLE();

    /**USART1 GPIO Configuration    
    PA2     ------> USART1_TX
    PA3     ------> USART1_RX 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);       
    HAL_NVIC_EnableIRQ(USART1_IRQn);               // Enable Interrupt
  }
}

Die Interruptbehandlung ist wie folgt:

void USART1_IRQHandler()
{
  HAL_UART_IRQHandler(&huart1);
}

Dies ist die eigentliche ISR und HAL_UART_IRQHandler(&huart1)eine von HAL definierte Handler-Funktion. Es prüft, welches Interrupt-Quellen-Flag gesetzt wurde, ruft einen Callback auf oder wartet auf den Empfang weiterer Bytes und löscht die Interrupt-Flags.

Im Falle von RX-Interrupts zählt dieser Handler die empfangenen Bytes und ruft bei Empfang der gewünschten Menge diese Callback-Funktion auf:

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if (huart->Instance == USART1)
  {
    // Your buffer is full with your data process it here or set a flag
  }
}

Der Callback hat eine schwache Deklaration, die müssen Sie implementieren.

Nun zur Nutzung. Zum Senden kann die folgende HAL-Funktion verwendet werden, dies ist die einfachste:

HAL_UART_Transmit(&huart1, (uint8_t*)"AT\r", 3, 0xFFFFFF)

Um mit Interrupt zu empfangen muss man folgende Funktion verwenden:

HAL_UART_Receive_IT(&huart1, uint8_t *pData, uint16_t size)

Dabei pDataist ein Zeiger auf den Empfangspuffer und sizedie Anzahl der erwarteten Bytes. Der HAL_UART_IRQHandler(&huart1)ruft den Rückruf auf, wenn die Anzahl der empfangenen Bytes gleich ist size.

All dies kann mit dem STM32CubeMX- Codegenerator generiert werden, mit Ausnahme der Callbacks, die nicht generiert werden.

Das GSM-Modul hat wahrscheinlich standardmäßig den Echo-Modus aktiviert, so dass AT\res mit antwortet \r\nAT\r\n\r\nOK\r\n, es sollten 12 Bytes gewartet werden.

Der Echomodus kann per ATE0Befehl deaktiviert und mit dem Befehl als Standard gespeichert werden AT&W. Daraus ergibt sich die Antwort \r\nOK\r\nauf die AT\r.

Ich hatte kürzlich ein ähnliches Problem mit meinem LTE-Modul. Es stellt sich heraus, dass viele solcher Module die Hardware-Flusskontrolle standardmäßig aktiviert haben. Sie können auch die HW-Flusskontrolle an Ihrem Ende verwenden oder einfach den CTS-Pin des Moduls erden.

Auch aus irgendeinem Grund wurde in meinem Fall die Beschriftung für RX/TX und RTS/CTS vertauscht. Wenn also die obige Lösung nicht funktioniert hat, können Sie es mit getauschten Verbindungen versuchen.

Danke Jungs für die Diskussion! Ich stand vor dem ähnlichen Problem. In meinem Fall habe ich Interrupts aktiviert (NVIC_EnableIRQ), HAL_UART_RxCpltCallback() und HAL_UART_Receive_IT() Call geschrieben.

Aber das habe ich übersehen:

void USART1_IRQHandler() { HAL_UART_IRQHandler(&huart1); }

Ohne den obigen Handler kann der Interrupt nicht von HAL_UART_RxCpltCallback() und der App abgefangen werden. tritt in eine Endlosschleife ein, da es keinen Interrupt-Handler sieht.