STM32F4 UART Pilote de HAL

J'ai décidé d'aller avec DMA pour obtenir le recevoir travail. Je suis à l'aide d'un 1 byte buffer circulaire de traiter les données comme il est tapé sur l'émetteur de série du terminal. Voici mon code final (uniquement la partie, plus d'infos sur les transmettre à la partie inférieure).

Certains définit et variables:

#define BAUDRATE              9600
#define TXPIN                 GPIO_PIN_6
#define RXPIN                 GPIO_PIN_7
#define DATAPORT              GPIOB
#define UART_PRIORITY         6
#define UART_RX_SUBPRIORITY   0
#define MAXCLISTRING          100 //Biggest string the user will type

uint8_t rxBuffer = '
#define BAUDRATE              9600
#define TXPIN                 GPIO_PIN_6
#define RXPIN                 GPIO_PIN_7
#define DATAPORT              GPIOB
#define UART_PRIORITY         6
#define UART_RX_SUBPRIORITY   0
#define MAXCLISTRING          100 //Biggest string the user will type
uint8_t rxBuffer = '\000'; //where we store that one character that just came in
uint8_t rxString[MAXCLISTRING]; //where we build our string from characters coming in
int rxindex = 0; //index for going though rxString
0'; //where we store that one character that just came in
uint8_t rxString[MAXCLISTRING]; //where we build our string from characters coming in
int rxindex = 0; //index for going though rxString

Configurer IO:

__GPIOB_CLK_ENABLE();
__USART1_CLK_ENABLE();
__DMA2_CLK_ENABLE();

GPIO_InitTypeDef GPIO_InitStruct;

GPIO_InitStruct.Pin = TXPIN | RXPIN;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(DATAPORT, &GPIO_InitStruct);

Configurer l'UART:

UART_HandleTypeDef huart1;
DMA_HandleTypeDef hdma_usart1_rx;

huart1.Instance = USART1;
huart1.Init.BaudRate = BAUDRATE;
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;
HAL_UART_Init(&huart1);

Configurer DMA:

extern DMA_HandleTypeDef hdma_usart1_rx; //assuming this is in a different file

hdma_usart1_rx.Instance = DMA2_Stream2;
hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart1_rx.Init.MemInc = DMA_MINC_DISABLE;
hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;
hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
HAL_DMA_Init(&hdma_usart1_rx);

__HAL_LINKDMA(huart, hdmarx, hdma_usart1_rx);

HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, UART_PRIORITY, UART_RX_SUBPRIORITY);
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);

Configurer DMA interrompre:

extern DMA_HandleTypeDef hdma_usart1_rx;

void DMA2_Stream2_IRQHandler(void)
{
    HAL_NVIC_ClearPendingIRQ(DMA2_Stream2_IRQn);
    HAL_DMA_IRQHandler(&hdma_usart1_rx);
}

Commencer DMA:

__HAL_UART_FLUSH_DRREGISTER(&huart1);
HAL_UART_Receive_DMA(&huart1, &rxBuffer, 1);

DMA recevoir de rappel:

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    __HAL_UART_FLUSH_DRREGISTER(&huart1); //Clear the buffer to prevent overrun

    int i = 0;

    print(&rxBuffer); //Echo the character that caused this callback so the user can see what they are typing

    if (rxBuffer == 8 || rxBuffer == 127) //If Backspace or del
    {
        print(" \b"); //"\b space \b" clears the terminal character. Remember we just echoced a \b so don't need another one here, just space and \b
        rxindex--; 
        if (rxindex < 0) rxindex = 0;
    }

    else if (rxBuffer == '\n' || rxBuffer == '\r') //If Enter
    {
        executeSerialCommand(rxString);
        rxString[rxindex] = 0;
        rxindex = 0;
        for (i = 0; i < MAXCLISTRING; i++) rxString[i] = 0; //Clear the string buffer
    }

    else
    {
        rxString[rxindex] = rxBuffer; //Add that character to the string
        rxindex++;
        if (rxindex > MAXCLISTRING) //User typing too much, we can't have commands that big
        {
            rxindex = 0;
            for (i = 0; i < MAXCLISTRING; i++) rxString[i] = 0; //Clear the string buffer
            print("\r\nConsole> ");
        }
    }
}

Donc c'est à peu près tout le code pour recevoir des caractères et de construire une chaîne de caractères (char tableau) qui indique que l'utilisateur a entré. Si l'utilisateur appuie sur la touche retour arrière ou suppr, le dernier caractère dans le tableau est remplacé et si ils ont frappé entrer, ce tableau est envoyé à une autre fonction et traitée comme une commande.

De voir comment l'analyse de commandes et de transmettre des code fonctionne, voir mon projet Ici

Grâce à @Flip et @Dormen pour leurs suggestions!

Le STM32 UART les pilotes sont un peu bancale. La seule façon dont ils fonctionnent hors de la boîte, si vous connaissez le nombre exact de caractères que vous allez recevoir. Si vous souhaitez recevoir un nombre quelconque de caractères, il existe quelques solutions que j'ai trouvé et essayé:

1. Définir le nombre de caractères à recevoir de 1 et de construire une chaîne distincte. Cela fonctionne, mais a des problèmes lors de la réception de données très rapide, parce que chaque fois que le pilote lit le rxBuffer il dissables de l'interruption, de sorte que certains caractères peuvent être perdues.

2. Définir le nombre de caractères à recevoir le plus possible la taille du message et de mettre en œuvre un dépassement de délai, après lequel l'ensemble du message est lu.

3. Écrire votre propre UART_Receive_IT fonction, qui écrit directement dans une mémoire tampon circulaire. C'est plus de travail, mais c'est ce que j'ai trouvé qui fonctionne le mieux dans la fin. Vous ne devez modifier certains de hal pilotes, donc le code est moins portable.

Une autre méthode consiste à utiliser le DMA comme @Flip suggéré.

Ont une approche différente de l'application de correctifs ex: "nul USART2_IRQHandler(void)" dans le fichier "stm32l0xx_it.c" (ou l4xx que nécessaire). Chaque fois qu'un caractère est reçu cette interruption est appelée. Il y a d'espace pour insérer du code d'utilisateur qui maintient inchangées lors de la mise à jour avec CubeMX générateur de code. Patch:

void USART2_IRQHandler(void)
{
  /* USER CODE BEGIN USART2_IRQn 0 */

  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE BEGIN USART2_IRQn 1 */
  usart_irqHandler_callback( &huart2 ); //patch: call to my function 
  /* USER CODE END USART2_IRQn 1 */
}

J'offre un petit tampon de caractère et de commencer à le recevoir de la fonction. Jusqu'à 115200 Bauds il n'a jamais consommé plus d ' 1 Octet en laissant le reste de la mémoire tampon utilisé.

st = HAL_UART_Receive_IT( &huart2, (uint8_t*)rx2BufIT, RX_BUF_IT_SIZE );

Lors de la réception d'un octet je le capturer et de le mettre à mon propre anneau de la mémoire tampon et de définir le caractère de pointeur et de gré à dos:

//placed in my own source-code module:
void usart_irqHandler_callback( UART_HandleTypeDef* huart ) {
  HAL_UART_StateTypeDef  st;
  uint8_t c;
  if(huart->Instance==USART2) {
    if( huart->RxXferCount >= RX_BUF_IT_SIZE ) {
      rx2rb.err = 2;           //error: IT buffer overflow
    }
    else {
      huart->pRxBuffPtr--;     //point back to just received char
      c = (uint8_t) *huart->pRxBuffPtr; //newly received char
      ringbuf_in( &rx2rb, c ); //put c in rx ring-buffer
      huart2.RxXferCount++;    //increment xfer-counter avoids end of rx
    }
  }
}

Cette méthode s'est révélée être plutôt rapide. La réception d'un seul octet de l'utiliser ou de DMA toujours de-initialise et les besoins de l'initialisation du processus de réception, qui s'est avéré être trop lent. Le code ci-dessus est seulement une image, j'ai utilisé pour compter les caractères de saut de ligne ici, dans un état de structure qui me permet de tout le temps de lire terminé lignes de l'anneau de la mémoire tampon. Également vérifier si la réception d'un caractère ou d'un autre événement a causé l'interruption doit être inclus.

EDIT:

Cette méthode a prouvé à travailler très bien avec USARTS qui ne sont pas pris en charge par la DMA et l'utiliser à la place.
À l'aide de DMA avec 1 octet en mode circulaire est plus court et plus facile à mettre en œuvre lors de l'utilisation de CubeMX générateur avec HAL bibliothèque.