STM32F4 UART Hal Driver

la réception de données alors que le Registre de données (DR) est plein entraînera une erreur de dépassement. Le problème est que la fonction UART_Receive_IT(UART_HandleTypeDef*) cessera de lire le registre DR une fois qu'il aura reçu suffisamment de données. Toute nouvelle donnée causera l'erreur de dépassement.

ce que j'ai fait était plutôt d'utiliser une structure de réception DMA circulaire. Vous pouvez ensuite utiliser currentPosInBuffer - uart->hdmarx->Instance->NDTR pour déterminer combien de données ont été reçues que vous n'avez pas encore traitées.

C'est un peu plus compliqué parce que tout le DMA fait le tampon circulaire lui-même, vous devez implémenter manuellement le loopback au début si vous passez la fin du tampon.

j'ai aussi trouvé un bug où le contrôleur dit qu'il a transféré les données (i.e. NDTR a diminué), mais les données ne sont pas encore dans la mémoire tampon. C'est peut-être un problème d'accès DMA / bus, mais c'est ennuyeux.

les pilotes de UART STM32 sont un peu chelous. La seule façon de les sortir de la boîte est de connaître 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 la quantité de caractères à recevoir à 1 et construire une chaîne séparée. Cela fonctionne, mais a des problèmes lors de la réception des données très rapide, parce que chaque fois que le pilote lit le rxBuffer il désactive l'interruption, de sorte que certains personnages peuvent être perdus.

2. définir la quantité de caractères à recevoir à la plus grande taille de message possible et mettre en œuvre un délai d'attente, après quoi le message entier est lu.

3. écrire votre propre fonction UART_Receive_IT, qui écrit directement dans un tampon circulaire. C'est plus de travail, mais c'est ce qui fonctionne le mieux à la fin. Vous devez changer certains pilotes hal, donc le code est moins portable.

une autre façon est d'utiliser DMA comme @Flip suggéré.

j'ai dû faire face au même problème dans mon projet. Ce que j'ai fait est de commencer à lire 1 octet avec HAL_USART_Receive_IT() juste après l'initialisation périphérique.

puis j'ai écrit un callback sur Transfert complet qui met le byte dans un buffer, met un drapeau si la commande est complète et ensuite appelle HAL_USART_Receive_IT() encore une fois pour un autre byte.

cela semble bien fonctionner pour moi puisque je reçois des commandes par L'intermédiaire de L'USART dont le premier octet me dit combien d'octets de plus la commande va être longue. Peut-être ça pourrait marcher pour toi aussi!

habituellement, j'ai écrit ma propre implémentation de tampon circulaire UART. Comme dit plus haut, les fonctions d'interruption UART de la bibliothèque HAL STM32 sont un peu étranges. Vous pouvez écrire votre propre tampon circulaire avec seulement 2 Tableaux et pointeurs en utilisant les drapeaux d'interruption UART.

avoir une approche différente patching par exemple" void USART2_IRQHandler(void) "dans le fichier" stm32l0xx_it.c" (ou l4xx si nécessaire). Chaque fois qu'un caractère est reçu cette interruption est appelée. Il y a de l'espace pour insérer du code utilisateur qui reste inchangé lors de la mise à jour avec CubeMX code generator. 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 */
}

je fournis un petit tampon de caractères et je démarre la fonction receive IT. Jusqu'à 115200 bauds il n'a jamais consommé plus de 1 octet laissant le reste de la zone tampon inutilisé.

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

quand je reçois un octet, je le capture et je le mets dans mon propre ring-buffer et je renvoie le caractère-pointer et-counter:

// 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 avérée assez rapide. Recevoir un seul octet en L'utilisant ou DMA dés-initialise toujours et doit initialiser à nouveau le processus de réception qui s'est avéré être trop lent. Le code ci-dessus est seulement un cadre; j'avais l'habitude de compter les caractères newline ici dans une structure d'état qui me permet à tout moment de lire lignes complétées à partir du ring-buffer. Aussi une vérification si un caractère reçu ou un autre événement a causé l'interruption doit être inclus.

EDIT:

Cette méthode a bien fonctionné avec les USARTS qui ne sont pas supportés par DMA et l'utilisent à la place. L'utilisation de Dma avec 1 byte en mode circulaire est plus courte et plus facile à mettre en œuvre lorsqu'on utilise CubeMX generator avec la bibliothèque HAL.