Firmware STM32F4 (UART)

Bonjour a tous, je suis entrain d’étudié un programme pour effectuer une liaison UART entre 2 carte STM32F429 et je bloque sur des conditions ternaires:

Code:

---

1 2 3

((((__INTERRUPT__) >> 28) == 1)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)): \ (((__INTERRUPT__) >> 28) == 2)? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)): \ ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & UART_IT_MASK)))

---

Dans ces lignes j'ai repéré comme opérateurs ?: (condition), |= (Affectation OU entre bits), >> (decalage a droite), & (ET entre bits) mais difficile a dechiffrer pour moi.

SI quelqu’un peut m'aider a comprendre ces quelques lignes je l'en remercie d'avance.

Cette ligne est beaucoup trop compliquée et est un bon exemple de ce qu'il ne faut pas faire. Qui a fait ? Histoire de le fouetter :aie:

La seule solution pour arriver à la déchiffrer est sans doute de la réindenter un peu mieux, par exemple comme ça :

Code:

---

1 2 3 4 5 6 7 8 9

((((__INTERRUPT__) >> 28) == 1) ? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)) : (((__INTERRUPT__) >> 28) == 2) ? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)) : ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & UART_IT_MASK)));

---

Personnellement, je n'ai pas vraiment envie de te dire exactement ce que ça fait ^^ Tu peux aussi traduire ça avec des if / else. Ici, tu peux commencer par :
- si __INTERRUPT__ décalé de 28 vers la droite vaut 1 (en gros, __INTERRUPT__ a pour partie haute 0b0001, probablement):
* on effectue un OU logique le champ CR1 et ((__INTERRUPT__) & UART_IT_MASK), on met ça dans CR1 et on "renvoie" cette valeur
- sinon:
* on fait un truc dans le même genre.

En écrivant ça, je viens de comprendre ce que fait ce code : il teste si la partie haute de __INTERRUPT__ vaut 1 (ou 2 ou autre chose, respectivement) et fait un OU logique entre le champ CR1, (ou CR2 et CR3, respectivement) et ((__INTERRUPT__) & UART_IT_MASK)) pour modifier ce champ, et "renvoie" la nouvelle valeur. Je ne vois pas d'affectation de la valeur de la structure ternaire, donc cette valeur est peut-être jetée. C'est dommage car c'est justement l'intérêt d'une structure ternaire : s'évaluer et donner une valeur.

Un code acceptable aurait été, sauf erreur de ma part :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

if((__INTERRUPT__ >> 28) == 1) { __HANDLE__->Instance->CR1 |= __INTERRUPT__ & UART_IT_MASK; } else if((__INTERRUPT__ >> 28) == 2) { __HANDLE__->Instance->CR2 |= __INTERRUPT__ & UART_IT_MASK; } else { __HANDLE__->Instance->CR3 |= __INTERRUPT__ & UART_IT_MASK; }

---

Je confirme, tu parles d'une horreur ! Pour ne plus rien y comprendre le jour où tu veux revoir le source, on ne peut pas faire mieux.

En ayant juste regardé les spec de ton micro (et pas la datasheet), je dirai que ce bout de programme détermine le quel UART à déclenché une interruption. Ton micro en possède plusieurs sauf erreur de ma part.

On dirait que ton micro gère 3 UART dans ton application ?

Il faudrait regarder dans la datasheet quel bit est CR1 et qu'est ce qu'on regarde avec interrupt décalé de 28 ?
Tu as le lien vers la datasheet pour qu'on regarde les registres qui concerne l'UART car quand je vais sur le site de ST, je tombe bien sûr la doc constructeur mais je n'ai pas d'info sur les registres !?

Bonjour,

merci pour vos réponse, il me semble nécessaire de rajouter un peu plus de code afin que vous arriviez a mieux cerner ce que fais le programme.

Debut de la fonction!

Code:

---

1 2 3 4 5 6 7 8 9 10 11

HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size) { uint32_t tmp = 0; tmp = huart->State; if((tmp == HAL_UART_STATE_READY) || (tmp == HAL_UART_STATE_BUSY_RX)) ..... ..... ..... /* Enable the UART Parity Error Interrupt */ __HAL_UART_ENABLE_IT(huart, UART_IT_PE);

---

Voir fichier uart.png pour la definition de la fonction

__HAL_UART_ENABLE_IT renvoi a un header ou se trouve les conditions ternaires:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/** @brief Enable the specified UART interrupt. * @param __HANDLE__: specifies the UART Handle. * This parameter can be UARTx where x: 1, 2, 3, 4, 5, 6, 7 or 8 to select the USART or * UART peripheral. * @param __INTERRUPT__: specifies the UART interrupt source to enable. * This parameter can be one of the following values: * @arg UART_IT_CTS: CTS change interrupt * @arg UART_IT_LBD: LIN Break detection interrupt * @arg UART_IT_TXE: Transmit Data Register empty interrupt * @arg UART_IT_TC: Transmission complete interrupt * @arg UART_IT_RXNE: Receive Data register not empty interrupt * @arg UART_IT_IDLE: Idle line detection interrupt * @arg UART_IT_PE: Parity Error interrupt * @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error) * @retval None */ #define UART_IT_MASK ((uint32_t)0x0000FFFF) #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28) == 1)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)): \ (((__INTERRUPT__) >> 28) == 2)? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)): \ ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & UART_IT_MASK)))

---

Pour la definition des bits voir usart_cr1 en attaché et voir message suivant pour usart_cr2 et usart_cr3

ci-joint les registres usart_cr2 usart_cr3.

Merci pour votre patience, j'ai essayé de mettre le plus d'info, j'espère que cela ne sera pas trop brouillon.

Il manque une info pour comprendre.
C'est le décalage de 28 pour le quel je n'ai pas ce qu'il faut :

((__INTERRUPT__) >> 28) == 1) fait une chose simple, tu dois avoir un registre de 32 bits quelque part :

xxxx 0000 0000 0000 0000 0000 0000 0000

Cette macro de la mort fait un décalage de 28 bits, de ce registre vers la droite ce qui donne :

0000 0000 0000 0000 0000 0000 0000 xxxx

Le but étant de regarder la valeur des x pour faire, si par exemple la première condition est rempli : (__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK))

Tu peux nous donner aussi la valeur de UART_IT_PE pour qu'on essaye de comprendre.

Bonjour,

UART_IT_PE:

Code:

---

#define UART_IT_PE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_PEIE))

---

Avec

Code:

---

#define UART_CR1_REG_INDEX 1

---

ET

Code:

---

#define USART_CR1_PEIE ((uint32_t)0x0100) /*!<PE Interrupt Enable

---

Et (__INTERRUPT__) doit etre soit le registre USART_SR (voir les fichiers attachés).

Selon ce qui est spécifié au debut de la macro:

@param __INTERRUPT__: specifies the UART interrupt source to enable.
* This parameter can be one of the following values:
* @arg UART_IT_CTS: CTS change interrupt
* @arg UART_IT_LBD: LIN Break detection interrupt
* @arg UART_IT_TXE: Transmit Data Register empty interrupt
* @arg UART_IT_TC: Transmission complete interrupt
* @arg UART_IT_RXNE: Receive Data register not empty interrupt
* @arg UART_IT_IDLE: Idle line detection interrupt
* @arg UART_IT_PE: Parity Error interrupt
* @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error)

Donc SI le registre USART_SR == 1 cela indique que le Bit 0 PE: Parity error a l'etat haut on retourne la première condition
SINON
SI le registre USART_SR == 2 cela indique que le Bit 1 FE: Framing error a l'état haut on retourne la seconde condition
SINON on retourne la dernière condition .

Soit (__INTERRUPT__) correspond a UART_IT_PE ???

Diffiicile de suivre lol !

Merci pour votre implication!

Ok, faisons un moonwalk (enfin je veux dire partons de la fin)

Première simplification du code

Code:

---

1 2 3 4

#define UART_CR1_REG_INDEX 1 #define USART_CR1_PEIE ((uint32_t)0x0100) /*PE Interrupt Enable*/ #define UART_IT_PE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_PEIE))

---

Si je simplifie ça cela donne :

Code:

---

1 2	#define UART_IT_PE ((uint32_t)(1 << 28 | 0x00000100))

---

UART_IT_PE vaut :
0001 0000 0000 0000 0000 0000 0000 0000 /* 1 << 28 */
OU
0000 0000 0000 0000 0000 0001 0000 0000 /* 0x00000100 */
______________________________________

= 0001 0000 0000 0000 0000 0001 0000 0000

UART_IT_PE = 0x10000100


Deuxième simplification du code

Code:

---

1 2 3 4 5

#define UART_IT_MASK ((uint32_t)0x0000FFFF) #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28) == 1)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)): \   (((__INTERRUPT__) >> 28) == 2)? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)): \   ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & UART_IT_MASK)))

---

Si on reprend la simplification très propre de Bktero cela donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

if((__INTERRUPT__ >> 28) == 1) { __HANDLE__->Instance->CR1 |= __INTERRUPT__ & 0x0000FFFF; } else if((__INTERRUPT__ >> 28) == 2) { __HANDLE__->Instance->CR2 |= __INTERRUPT__ & 0x0000FFFF; } else { __HANDLE__->Instance->CR3 |= __INTERRUPT__ & 0x0000FFFF; }

---

Intégration de la simplification dans le code

ok..... maintenant qu'on a ton code juste en dessous et que l'on connait les deux simplifications du dessus :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size) { uint32_t tmp = 0;   tmp = huart->State; if((tmp == HAL_UART_STATE_READY) || (tmp == HAL_UART_STATE_BUSY_RX)) ..... ..... ..... /* Enable the UART Parity Error Interrupt */ __HAL_UART_ENABLE_IT(huart, UART_IT_PE);

---

On va faire entrer toutes les simplifications là dedans et commenter ce qui se passe ! Ce qui donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size) { uint32_t tmp = 0;   tmp = huart->State; if((tmp == HAL_UART_STATE_READY) || (tmp == HAL_UART_STATE_BUSY_RX)) ..... ..... ..... /* DEBUT DE LA SIMPLIFICATION */   /* Enable the UART Parity Error Interrupt */ /* __HAL_UART_ENABLE_IT(huart, UART_IT_PE); */     /* A CETTE ENDROIT AU LIEU DE FAIRE __HAL_UART_ENABLE_IT(huart, UART_IT_PE);   * QUI EST UN #DEFINE ON VA INTEGRER CE QUE BKTERO A SIMPLIFIER ET REMPLACER   * UART_IT_PE PAR LA VALEUR QUE NOUS AVONS CALCULER TOUT AU DEBUT   */   if((0x10000100 >> 28) == 1) { /* C'EST VRAI !!!!! puisque 0x10000100 = 0001 000 000 000 0000 0001 0000 0000 et si on décale de 28 vers la droite cela donne : 0000 0000 0000 0000 0000 0000 0000 0001 */ huart->Instance->CR1 |= 0x10000100 & 0x0000FFFF; /* ça revient a faire huart->Instance->CR1 = 0x0000100; (en binaire pour mieux comprendre : 0000 0000 0000 0000 0000 0001 0000 0000   en français : mettre a 1 le bit n°8 (le premier à droite étant le bit 0) dans le registre CR1 qui est PEIE et qui active une interruption sur une erreur de parité dans une trame de réception de l'UART   ça tombe bien puisque c'est bien UART_IT_PE que l'on voulait activer ! Sans ça on aurait eu l'air fin lol   */ }

---

Explication

Maintenant si on remet ça dans le contexte je dirai que l'horrible condition ternaire redirige l'interruption désirée automatiquement dans le bon registre CR via une directive du préprocesseur #define pour que tu n'aies pas à le faire toi même.
Cela permet de faire abstraction de l'endroit où se trouve les bits à activer en fonction de l'interruption choisie.... Ce qui est pourtant primordial à mes yeux d'électronicien ! Mais c'est le but d'un Framework.

Par exemple, dans CR2 il y a le bit 6 qui déclenche une interruption. Dans CR3 tu as le bit 8 qui déclenche une interruption et dans CR1 tu en as aussi.

Donc si tu refais la démonstration du dessus avec chaque valeur UART_IT_quelque chose tu devrais trouver ce qui suit :
* @arg UART_IT_CTS: CTS change interrupt => la condition ternaire devrait te renvoyer vers CR3 pour mettre le bit 9 à 1
* @arg UART_IT_LBD: LIN Break detection interrupt => la condition ternaire devrait te renvoyer vers CR2 pour mettre le bit 6 à 1
* @arg UART_IT_TXE: Transmit Data Register empty interrupt => la condition ternaire devrait te renvoyer vers CR1 pour mettre le bit 7 à 1
* @arg UART_IT_TC: Transmission complete interrupt => la condition ternaire devrait te renvoyer vers CR1 pour mettre le bit 6 à 1
* @arg UART_IT_RXNE: Receive Data register not empty interrupt => la condition ternaire devrait te renvoyer vers CR1 pour mettre le bit 5 à 1
* @arg UART_IT_IDLE: Idle line detection interrupt => la condition ternaire devrait te renvoyer vers CR1 pour mettre le bit 4 à 1
* @arg UART_IT_PE: Parity Error interrupt => la condition ternaire devrait te renvoyer vers CR1 pour mettre le bit 8 à 1
* @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error) => la condition ternaire devrait te renvoyer vers CR1 pour mettre le bit 15 à 1

C'était pas simple étant donné qu'on avait qu'une partie de ton programme mais tu ne pouvais peut être pas tout donner et tu nous as donné que très peu d'info sûrement pour la même raison. De plus, je ne connais pas ce Framework et je n'ai jamais utilisé de micro de chez ST !
C'est un programme qui n'est peut être pas ta propriété intellectuelle ?

Est ce que tu as compris ? Veux tu que je l'explique autrement ? Si oui il va me falloir les valeurs des UART_IT_xx à minima
A+

Vincent

Eh bien un grand merci pour ton aide, oui j'ai pigé!
Juste avant ta réponse j'ai tenté de manipuler les bits ( ca fait bizarre de dire ca !) mais par manque de concentration j'ai mélangé decimale avec héxa pour la valeur:

Code:

---

#define USART_CR1_PEIE ((uint32_t)0x0100)

---

Bref c'est de l'histoire ancienne ;).

Juste une petit point d’éclaircissement ==> huart->Instance->CR1 |= 0x10000100 & 0x0000FFFF; équivaut a ==> huart->Instance->CR1 = 0x10000100 & 0x0000FFFF; ?
Parce que je vois bien le & dans ton exemple mais ensuite tu fais un OU avec le resultat du & et le registre CR1, ce qui implique que USART_CR1 a ce moment la vaut 0x00000000 ?

Donc huart est un pointeur sur le pointeur du registre USART_CR1 ?

Voici les valeurs de UART_IT_xx:

Code:

---

1 2 3 4 5 6 7 8 9 10

#define UART_IT_PE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_PEIE)) #define UART_IT_TXE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_TXEIE)) #define UART_IT_TC ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_TCIE)) #define UART_IT_RXNE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_RXNEIE)) #define UART_IT_IDLE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_IDLEIE)) #define UART_IT_LBD ((uint32_t)(UART_CR2_REG_INDEX << 28 | USART_CR2_LBDIE)) #define UART_IT_CTS ((uint32_t)(UART_CR3_REG_INDEX << 28 | USART_CR3_CTSIE)) #define UART_IT_ERR ((uint32_t)(UART_CR3_REG_INDEX << 28 | USART_CR3_EIE))

---

Code:

---

1 2 3

#define UART_CR1_REG_INDEX 1 #define UART_CR2_REG_INDEX 2 #define UART_CR3_REG_INDEX 3

---

Code:

---

1 2 3 4 5 6 7

#define USART_CR1_TXEIE ((uint32_t)0x0080) /*!<PE Interrupt Enable #define USART_CR1_IDLEIE ((uint32_t)0x0010) /*!<IDLE Interrupt Enable */ #define USART_CR1_RXNEIE ((uint32_t)0x0020) /*!<RXNE Interrupt Enable */ #define USART_CR1_TCIE ((uint32_t)0x0040) /*!<Transmission Complete Interrupt Enable */ #define USART_CR2_LBDIE ((uint32_t)0x0040) /*!<LIN Break Detection Interrupt Enable */ #define USART_CR3_EIE ((uint32_t)0x0001) /*!<Error Interrupt Enable */ #define USART_CR3_CTSIE ((uint32_t)0x0400) /*!<CTS Interrupt Enable */

---

Merci

Exemple suivant:

Code:

---

1 2 3 4 5 6 7 8

/* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_UART_ENABLE_IT(huart, UART_IT_ERR); #define UART_IT_ERR ((uint32_t)(UART_CR3_REG_INDEX << 28 | USART_CR3_EIE)) #define UART_CR3_REG_INDEX 3 #define USART_CR3_EIE ((uint32_t)0x0001) /*!<Error Interrupt Enable */

---

UART_IT_ERR vaut :
0011 0000 0000 0000 0000 0000 0000 0000 /* 3 << 28 */
OU
0000 0000 0000 0000 0000 0000 0000 0001 /* 0x0000001 */
______________________________________

= 0011 0000 0000 0000 0000 0000 0000 0001

UART_IT_ERR = 0x30000001


Avec ce résultat on obtient:

Code:

---

(((__INTERRUPT__) >> 28) == 3)

---

Donc on execute:

Code:

---

__HANDLE__->Instance->CR3 |= __INTERRUPT__ & 0x0000FFFF;

---

Ce qui donne:

Code:

---

__HANDLE__->Instance->CR3 = 0b 0000 0000 0000 0000 0000 0000 0000 0001;

---

On vient mettre a 1 le bit 0 de CR3.

Definition du bit0 du registre USART_CR3:

Bit 0 EIE: Error interrupt enable
Error Interrupt Enable Bit is required to enable interrupt generation in case of a framing
error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USART_SR register) in
case of Multi Buffer Communication (DMAR=1 in the USART_CR3 register).
0: Interrupt is inhibited
1: An interrupt is generated whenever DMAR=1 in the USART_CR3 register and FE=1 or
ORE=1 or NF=1 in the USART_SR register.

Ca a l'air bon !

A noter qu'il faut a chaque fois un autre flag ds USART_SR pour déclencher une interruption!

Citation:

---

Envoyé par julien terrier

Juste avant ta réponse j'ai tenté de manipuler les bits ( ca fait bizarre de dire ca !)

---

C'est normal mais après on s'habitue à ce vocabulaire.... c'est peut être pour ça que mon 4ème enfants arrivera en février :mrgreen:

Citation:

---

Envoyé par julien terrier

Juste une petit point d’éclaircissement ==> huart->Instance->CR1 |= 0x10000100 & 0x0000FFFF; équivaut a ==> huart->Instance->CR1 = 0x10000100 & 0x0000FFFF; ?
Parce que je vois bien le & dans ton exemple mais ensuite tu fais un OU avec le resultat du & et le registre CR1 ?

---

Ah ! Désolé, j'ai oublié de détailler ceci dans mon commentaire dans ton code. J'ai été trop vite dans l'explication.
La réponse à la question est non mais c'est presque ça.

Comme tu sembles a l'aise avec les opérateurs bit à bit, je ne pense pas nécessaire de t'expliquer comment fonctionne et ET ou un OU !?

1 Détaillons :
huart->Instance->CR1 |= 0x10000100 & 0x0000FFFF;

2 On peut l'écrire, sans le raccourci d'écriture :
huart->Instance->CR1 = (huart->Instance->CR1 | (0x10000100 & 0x0000FFFF));

3 On va faire les calculs par ordre défini par les parenthèses en faisant d'abord :
(0x10000100 & 0x0000FFFF) cela donne, puisque c'est maque de type "ET" -> 0x00000100

4 Ce qui fait, si on réintègre ça dans l'étape 2 :
huart->Instance->CR1 = (huart->Instance->CR1 | 0x00000100);

5 Comment interpréter l'étape 4 ?
On peut lire ça comme suit : Lire le registre CR1 faire un OU avec la valeur 0x00000100 et remettre le tout dans CR1
Pour rappel, lorsqu'on fait un OU cela permet de mettre un ou des bit(s) à 1. A contrario un ET permet de mettre un ou des bit(s) à 0

Donc par cette ligne huart->Instance->CR1 |= 0x10000100 & 0x0000FFFF; on demande bien de mettre à 1 uniquement les bits 0x00000100 (en l'occurrence ici il n'y a qu'un bit a mettre à 1)

Citation:

---

Envoyé par julien terrier

Donc huart est un pointeur sur le pointeur du registre USART_CR1 ?

---

Humm... il me manque des infos mais je suis prêt à parier que huart est un pointeur vers une structure qui défini un UART parmi les autres UART que ton micro dispose (mais pas le registre CR1)
Dans ton code quelque part et avant d'appeler la fonction HAL_UART_Transmit_IT, tu devrais trouver probablement une instance new si c'est du C++ ou un malloc si c'est du C pour "pointer ou instancier un UART"


Hé bien ! tu as été plus rapide que moi, j'étais entrain d'écrire la démonstration pour voir si quand j'ai écrit :
UART_IT_CTS: CTS change interrupt => la condition ternaire devrait te renvoyer vers CR3 pour mettre le bit 9 à 1

C'était vrai !

Je vois que tu as tout compris, tant mieux (je peux finir ma bière !)

Je m'auto réponds pour la question sur le pointeur du pointeur lol

Oui car:

Code:

---

1 2 3 4 5 6 7

typedef struct { USART_TypeDef *Instance; /*!< UART registers base address */ ... ... ... }UART_HandleTypeDef;

---

Citation:

---

Envoyé par julien terrier

A noter qu'il faut a chaque fois un autre flag ds USART_SR pour déclencher une interruption!

---

Ah... pas vraiment, à moins que ma bière ne soit trop forte moi je lis qu'il faut venir lire le registre USART_SR pour effacer le flag et ainsi permettre à l'interruption de se redéclencher la prochaine fois.
Quasiment tous les micro que j'ai utilisé fonctionne de cette façon (Microchip, Texas, Atmel, NXP et Toshiba)

Décidément tout ce croise ! J'avais répondu a ton auto-réponse et nous sommes tous deux d'accord

Félicitation pour votre (toi & ta femme) futur 4 ème chef d'oeuvre!

Effectivement on ce croise !

Je viens de lire ton commentaire (je me permets de te tutoyer) effectivement, j'ai dit une bourde car j'ai mal interprété ceci:

An interrupt is generated whenever DMAR=1 in the USART_CR3 register and FE=1 or
ORE=1 or NF=1 in the USART_SR register.

En tous cas merci pour ton aide

Merci beaucoup Julien !
Et y a pas de quoi, heureux de t'avoir aider.

Pense a mettre ce sujet en Résolu, si c'est le cas ! (pour la bonne tenue du forum) a moins que tu ne l'ai fait pendant que j'écrivais !

Bonne continuation à toi, peut être à bientôt et salutation de ch'Nord (où y fait un temps de chiotte vin di d'jousse !)
Vincent

Peut etre que j'ai mal interprété ton explication sur la façon de déclenché l'interruption mais il me semble que selon le diagram mis en attaché il faut bien réunir des conditions OU et ET!

Pour declencher ERROR_INTERRUPT il faut que :

ou FE ou NE ou ORE soit a 1

ensuite si l'un des trois ou les deux ou les trois sont a 1 il faut que:

EIE et DMAR soit a 1 pour declencher l'interruption!

Et pour PARITY_ERROR

IL faut que PE et PEIE soit a 1

Bonsoir du sud-est il fait beau et chaud !

Nb: ma femme est née a Arras et ses grand-parents habite toujours bucquoy chtio magette!

Alors là je suis sur le cul, le monde est petit !

Tu sais d'où je suis natif ?
Ayette à 5km de Bucquoy ! Et j'ai acheté une maison, il y a 1 an à "Achiet le Grand" toujours à 5km de Bucquoy (je te vois déjà te marrer mais demande à t'femme.. on prononce ça Achiette et pas "A chier" comme je peux l'entendre de l'autre bout de la france ! Et elle doit très bien voir où c'est)

Pour la question, je te fais une réponse demain soir car là j'ai plus le temps.
A demain t'cho bino

J'ai traduis la datasheet

Citation:

---

USART_CR1
Bit6 TCIE: Activation de l'interruption "Transmission complète"

Ce bit est mise à 1 et à 0 par logiciel
0: L'interruption est désactivée
1: Une interruption USART est générée à chaque fois que le bit TC=1 dans le registre USART8_SR

USART_SR
Bit6 TC: Transmission complète

Ce bit est mis a 1 de manière materielle (donc automatique) si la transmission d'une trame
contenant des données est complète et si le bit TXE est à 1 (pour info TXE mis a 1 de manière
matérielle donc automatiquement lorsque le registre d'envoi est vide et que les données sont
parties). Une interruption est générée si le bit TCIE=1 dans le registre USART_CR1. Il est
mis à 0 par une séquence logicielle (une lecture du registre USART_SR suivie par une écriture
dans le registre USART_DR). Le bit TC peut aussi effacer en écrivant 0 dessus. Cette séquence
séquence d'effacement est recommandé seulement pour une communication multibuffer.
0: Transmission incomplète
1: Transmission complète

---

Si par exemple tu veux déclencher une fonction d'interruption lorsque qu'une trame est partie de l'UART.


- Tu dois mettre le bit TCIE à 1 dans le registre USART8_SR
- Une fois qu'une trame est partie de l'UART en question, ce qui implique forcément que le bit TXE passe à 1 puisqu'il signifie que le registre d'envoi est vide (Transmit Register Empty) alors le bit (flag) TC passera à 1 automatiquement et cela va déclencher une interruption.
- Une fois que ton micro est dans la fonction d'interruption, la première chose a faire c'est de remettre le bit TC à 0 pour qu'une nouvelle interruption puisse être appelée lors du prochain envoi d'une trame de l'UART. Puis tu fais ce que tu as à faire dans cette fonction d'interruption.
- Une fois que le micro en a fini avec la fonction d'interruption, le compteur programme va retourner là où il a été interrompu et va reprendre sa vie jusqu'a une nouvelle interruption.



Après, la datasheet parle d'une séquence d'éffacement du bit TC au travers du registre USART_DR mais je n'ai pas la descritpion de ce que c'est.

Ce mode de fonctionnement est présent sur beaucoup de micro-contrôleurs 8/16/32 bits autres que les architectures ARM comme le tien.

Si tu regardes bien le rôle de TC, tu comprendra aussi que tu peux aussi t'en servir sans forcément déclencher une interruption. Donc en faisant ce qu'on appel du pooling puisque TC est mis à 1 par ton micro une fois qu'une trame est envoyée. C'est à dire simplement une boucle while, en C par exempe, dans ton programme principal et qui ferai :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

/* j'envoi une trame */ .... .... ....   while(TC==0) /* tant que la trame n'est pas partie */ ; /* attendre */   TC = 0; /* la trame est partie, je suis sortie de ma boucle d'attente et je remets TC à 0 */   /* j'envoi une trame */ .... .... ....   while(TC==0) /* tant que la trame n'est pas partie */ ; /* attendre */   TC = 0; /* la trame est partie, je suis sortie de ma boucle d'attente et je remets TC à 0 */   /* j'envoi une trame */ .... .... ....

---

Bien sur cette manière de faire est souvent mal venu sur un micro car cela impliquerai qu'il attende sans rien faire d'autre à côté. Souvent on abuse volontier des interruptions sur ces béstioles car bien plus pratiques et rapides et aussi cela permet de faire plusieurs choses en parallèle (j'ai pas dit en même temps.)

A+

Hello,
je suis content de te connaitre! Grâce a toi j'ai saisie le mécanisme, je sens que je vais tellement te solliciter que tu vas me détester lol! Il me reste tant de chose a explorer sur cette petite bébête de STM32 !

Bref bien le bonjour chez toi et encore merci pour ton aide!

Peut-etre que tu connais la famille Vaast a Douchy-lès-ayette?

La tante de ma femme habite également a Beaurain et son cousin a Arras!

Bucquoy,Ayette, Beaurain,Arras tu es cerné lol !

Je suis monté 2 fois cette année a Bucquoy on s'est peut etre croisé qui sait lol, ma voiture est immatriculée 62 ;)!

A+