STM32 HAL USART recevoir par interruption

J'ai du mal à recevoir des données sur l'USART. Ce que je veux réellement à atteindre les ist, que je peux recevoir une commande de plus de USART avec de la longueur (seulement une longueur maximale possible). J'ai donc utiliser la routine d'interruption pour vérifier chaque caractère reçu, mais j'ai en quelque sorte toujours pas possible d'obtenir ce que je veux. La routine est appelée à chaque fois que je reçois un nouveau personnage, mais de toute façon HAL_UART_Receive_IT(&huart1,rx_data,buff_size_rx) n'est pas mise à jour en temps réel, alors je ne vois pas reçu de caractère lorsque je vérifie rx_data[pointeur], mais quelques temps plus tard, il est dans le rx_data tampon.

Ce que j'ai à ce jour:

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]=='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 */
}
') {
              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 */
}

quel est le point de dupliquer le tampon de la mise en œuvre? BTW, vous ne pouvez pas appeler HAL_UART_Receive_IT de là, et ensuite appeler HAL gestionnaire d'irq qui l'appelle à nouveau. Faire nu registres ou HAL, pas les deux. De toute façon HAL pour la simple périphérique comme uart?
Qu'entendez-vous par dublicating le tampon de la mise en œuvre? J'aimerais réaliser cela dans HAL, mais j'ai vraiment pas trouvé de solution pour le moment. DMA serait bien, mais là, j'ai besoin d'une longueur fixe pour chaque commande ou l'utilisation d'un délai d'attente, ce qui n'est pas pris en charge par HAL pour une STM32F303K8T6.
Hal t-il. Vous ne devriez pas faire quoi que ce soit avec le buffet si vous utilisez hal. Je voudrais mettre en œuvre nus resister moi-même, mais il est de votre code, sans cette stupide de la bibliothèque. Combien de temps vos messages? Si bref il n'y a pas de point de DMA.
Bien que les messages ne sont que d'environ 16 caractères. Si j'utilise juste HAL_UART_Receive_IT, il va écrire les caractères de la rx_data tampon, mais je ne jamais voir si j'ai reçu un caractère nul et il agit comme un tampon en anneau, qui ne fonctionne que pour une longueur fixe.
Regarde le code que j'utilise pour recevoir arbitraire des données GPS here. Il utilise HAL, mais les raccourcis de l'interruption. Si je devais le refaire je vidage de HAL et d'aller à la plaine CMSIS.
OMI DMA pour les 16 octets n'est pas la peine
Soares nue registre, CMSIS n'est que le tas de définitions & certaines fonctions inline.
Yep, pas de bibliothèques.

InformationsquelleAutor HansPeterLoft | 2017-09-13

hal stm32

5

HAL_UART_Receive_IT() n'est pas destiné à être appelée à partir d'un gestionnaire d'interruption de cette façon, mais pour initier la réception d'un fixe nombre d'octets via l'interrompre.

Une solution possible est de vérifier votre tampon d'entrée après HAL_UART_IRQHandler() complète, c'est à dire dans le /* USER CODE BEGIN USART1_IRQn 1 */ section. Lorsqu'une commande est traitée, vous pouvez réinitialiser pRxBuffPtr et RxXferCount dans la poignée de la structure de leurs valeurs d'origine pour démarrer à partir du début de la mémoire tampon de nouveau.

Un autre ~~horrible~~ solution possible serait d'appeler HAL_UART_Receive_IT() avec une taille de mémoire tampon de 1, et mis en place un HAL_UART_RxCpltCallback() gestionnaire qui vérifie la réception de l'octet à chaque fois, et les appels HAL_UART_Receive_IT() à nouveau si nécessaire.

Bien sûr, vous pourriez le faire sans HAL, comme PeterJ et d'autres (toujours) suggèrent.
- Vous avez déjà mis en place la broche et de l'interruption de l'installation, laisser inchangés au premier abord.
- Calculer la UART->BRR valeur selon le manuel de référence, ou de copier le code de hal.
- ensemble UART->CR1=USART_CR1_RE|USART_CR1_TE|USART_CR1_UE|USART_CR1_RXNEIE; Maintenant, vous obtenez des interruptions.
- Dans la fonction d'interruption, lire UART->SR dans une variable temporaire, et de l'examiner.
- Lire UART->DR lorsqu'il y a réception d'un octet d'attente, faire de la gestion d'erreur dans le cas contraire (plus tard).
- Se débarrasser du reste de la couche d'abstraction matérielle des appels lorsque le dessus est le travail.
Interruption de réponse et le temps de traitement est souvent critique dans les applications embarquées, et HAL déchets juste le beaucoup de.
- Merci, je vais essayer la solution de contournement en premier. Mais comment voulez-vous réinitialiser pRxBuffPtr et RxXferCount? Je veux dire que le pointeur a besoin d'une adresse?
- est appelé dans le HAL gestionnaire d'IRQ. Avez-vous déjà vu comment ce gestionnaire est mis en œuvre. Cette fonction fait le phisique de lecture de l'U(S)de l'ART et place les données dans la mémoire tampon de réception. Horrible la mise en œuvre de toute façon.
- Dans laquelle HAL version? J'ai vérifié quelques versions qui trainent sur mon disque, mais HAL_UART_Receive_IT() n'est jamais appelé dans le HAL_UART_IRQHandler(), ou n'importe où ailleurs dans le HAL bibliothèques. La réelle lecture de la USART->DR registre se produit dans UART_Receive_IT() (sans le HAL_ préfixe), qui est déclarée statique, n'est pas accessible à partir du programme utilisateur.
- définir le début (c'est un pointeur) et la longueur de votre tampon de réception.
InformationsquelleAutor berendi - protesting

La normale HAL bibliothèque n'est pas utile pour la réception continue ou de commandes avec des longueurs différentes.

Si vous avez la complète HAL paquet installé, vous pouvez regarder les exemples de la LuxLevel interface.

Projects\STM32F411RE-Nucleo\Examples_LL\USART\USART_Communication_Rx_IT_Continuous

La chose principale est de vous usart à la réception continue:

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);
}

L'USART C'Gestionnaire devrait ressembler à

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();
  }
}

La dernière chose à configurer est le Rappel

void USART_CharReception_Callback(void);

Où vous pourriez mettre les octets dans un tampon et de les traiter dans la boucle principale, ou où vous voulez.

InformationsquelleAutor theSealion

1

Depuis que je suis tombé sur le problème aujourd'hui et ne pouvait pas trouver une bonne solution, je tiens à vous présenter un très simple, à l'aide de la plupart de la couche d'abstraction matérielle, mais en évitant les problèmes décrits...

Court verison de mon approche est la suivante:

Dans le dernier utilisateur section de code (pour le USART exemple, si vous utilisez plus d'un) de void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle), activer l'IRQ avec:
```
__HAL_UART_ENABLE_IT(&huartx, UART_IT_RXNE);
```
Puis mettre le code souhaité dans votre fonction d'interruption:
```
void USART3_IRQHandler(void)  {    
    /* USER CODE BEGIN USART3_IRQn 0 */
    CallMyCodeHere();
    return;  //To avoid calling the default HAL handler at all 
             //(in case you want to save the time)
    /* USER CODE END USART3_IRQn 0 */
    HAL_UART_IRQHandler(&huart3);  //This is the CubeMX generated HAL handler
    /* USER CODE BEGIN USART3_IRQn 1 */
    /* USER CODE END USART3_IRQn 1 */ 
}
```
Ne pas utiliser HAL_UART_Receive_IT n'importe où, il va désactiver l'IRQ et vous avez besoin de ré-activer, si vous voulez obtenir appelée à chaque réception.

La version longue peut être trouvé dans mon post ici...

InformationsquelleAutor themole

Vous devez vous connecter pour publier un commentaire.