Discussion :

[dje8269]

Bonjour à tous,

je débute avec stm32 IDE .
Je souhaiterais pouvoir utiliser la fonction ci dessous par exemple dans un fichier séparé du main.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

HAL_UART_Transmit(&huart2, (uint8_t *)"coucou", 6, 100);

D’après ce que j'ai compris je dois tout débord créer un couple .c et .h que je nommerai uart.c et uart.h étant donné que je cherche à envoyer une trame uart depuis un autre fichier .c

Dans mon main.c créer par cube MX j'ai donc ceci créer automatiquement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
UART_HandleTypeDef huart2;
 
int main(void)
{
   HAL_Init();
---
  MX_GPIO_Init();
  MX_USART2_UART_Init();
 ---
---
---
  while (1)
{
     mon code
}
 
 
void MX_USART2_UART_Init(void)
{
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 38400;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
}

Comme j'ai créer un couple de fichier uart.c et uart.h
je rajoute ceci dans la portion include prévue a cet effet dans le fichier main.c.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include "uart.h"

ensuite je créer mon uart.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#ifndef UART_H_   /* Include guard */
 
#define UART_H_
 
#include <stdio.h>
 
void message(void);  // prototype de focntion
 
#endif

puis je créer mon uart.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
#include "uart.h" /* Include de mon header  */
 
void message(void)
{
	HAL_UART_Transmit(&huart2, (uint8_t *)"coucou", 6, 100);
}

J'obtiens bien entendu un code erreur m'indiquant que l'argument &huart2 / error: 'huart2' undeclared (first use in this function)

J'ai donc essayé de faire connaitre cet argument en utilisant le mot "extern" en plaçant cette ligne de code de le fichier uart.c avec cette ligne de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

extern UART_HandleTypeDef huart2;

Du coup je me retrouve ace une autre erreur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

error: unknown type name 'UART_HandleTypeDef'

Je ne sais plus quoi faire.

Le but est donc de pouvoir utiliser la fonction HAL_UART_Transmit...... dans un fichier uart.c


Merci à vous si vous arrivez à éclairer ma lanterne pour faire fonctionner cette portion de code.

[foetus]

Comme tu es dans 1 unité de compilation (1 fichier .c avec ces includes), tu peux mettre des includes dans uart.c #include <stm32f4xx_hal_uart.h>.

Trouvé ici : UART_HandleTypeDef Struct Reference

Ensuite pour le extern, pourquoi pas. Mais ta variable huart2 devient 1 variable globale.
Pense à l'injection de dépendances (en gros passe là en paramètre)

[Sve@r]

Bonjour

J'obtiens bien entendu un code erreur m'indiquant que l'argument &huart2 / error: 'huart2' undeclared (first use in this function)

Si "uart.c" utilise un truc extérieur (ici "huart2"), il lui faut inclure le ".h" correspondant.
Par exemple si "uart.c" utilise printf(), il devra inclure <stdio.h>. Ben c'est la même chose.

De là, 2 possibilités

• "uart.c" est autonome (il utilise "huart2" mais il fait office de "boite noire" et l'appel de "huart2" est invisible pour l'appelant) et tu peux alors inclure le ".h" de "huart2" dans "uart.c"
• "uart.c" fait juste office de surcouche (il utilise "huart2" mais l'appelant devra aussi l'utiliser donc l'appelant ayant besoin de "huart2", devra aussi inclure le ".h" correspondant), tu peux mutualiser cet include en le mettant dans "uart2.h". Ainsi l'appelant, en incluant simplement "uart2.h", aura accès aux fonctions de "uart2.c" ainsi qu'à "huart2".

[dje8269]

Merci foetus de cette réponse rapide.

En rajoutant seulement la librairie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <stm32f3xx_hal_uart.h>

comme tu me le préconise, j'ai 76 erreurs qui apparaissent.

En rajoutant toute la librairie HAL c'est mieux, je n'ai que 2 erreurs :
error: 'huart2' undeclared (first use in this function)

J'utilise un stm32F3 le code de mon uart.c devient donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#include "uart.h" /* Include the header  */
#include <stm32f3xx_hal.h>
 
void message(void)
{
	HAL_UART_Transmit(&huart2, (uint8_t *)"coucou", 6, 100);
}

Toujours mon problème de déclaration de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

&huart2

En rajoutant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

extern UART_HandleTypeDef huart2;

je n'ai plus d'erreur. Mais j'avoue ne pas comprendre le pourquoi du comment.

Donc sans erreur, cela donne
uart.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#ifndef UART_H_   /* Include guard */
 
#define UART_H_
 
void message(void);  // prototype de fonction
 
#endif

et mon uart.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
#include "uart.h" /* Include the header  */
#include <stm32f3xx_hal.h>
 
extern UART_HandleTypeDef huart2; 
 
void message(void)
{
	HAL_UART_Transmit(&huart2, (uint8_t *)"coucou", 6, 100);
}

J'ai l'impression que mon uart.h ne sert pas a grand chose au final.

Pense à l'injection de dépendances (en gros passe là en paramètre)

Euh j'ai pas tout compris la !

[foetus]

Euh j'ai pas tout compris la !

Ton erreur est l'erreur de base Il faut ouvrir des livres pour apprendre la conception, l'appartenance, …

La solution basique :
main.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// ...
#include <uart.h> // inclut aussi stm32f3xx_hal.h
 
 
 
int main(void /*int argc, char* argv[]*/)
{
// ...
    UART_HandleTypeDef huart2; // la variable n'est plus globale : extern est impossible
// ...
    message(&huart2); // on passe l'adresse
// ...
 
}

uart.h : c'est ce que @Sve@r te disait "uart.c" fait juste office de surcouche -> uart.c inclut stm32f3xx_hal.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include <stm32f3xx_hal.h>
 
#ifndef UART_H_   /* Include guard */
 
#define UART_H_
 
void message(UART_HandleTypeDef*);
 
#endif

uart.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#include "uart.h"
 
void message(UART_HandleTypeDef* huart2) {
    if (huart2 != NULL) {
        HAL_UART_Transmit(huart2, (uint8_t *)"coucou", 6, 100);
   } /* else error */
}

c'est la solution basique parce que je ne connais pas ce que tu veux faire. Mais je pense que uart doit créer 1 structure pour stocker le handle fournit par le main.

[dje8269]

Merci foetus et Sve@r,

Effectivement la lecture permet de savoir où l'on met les pieds mais difficile de comprendre tout de même, sans explication et seulement avec des exemples.

Plusieurs chose que je ne comprend pas .

dans le main.c tu indiques

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
// ...
#include <uart.h> // inclut aussi stm32f3xx_hal.h 
 
int main(void /*int argc, char* argv[]*/)
{
// ...
    UART_HandleTypeDef huart2; // la variable n'est plus globale : extern est impossible
// ...
    message(&huart2); // on passe l'adresse
// ...
 
}

Mais

UART_HandleTypeDef huart2;

est généré automatiquement à la configuration. Cette déclaration se trouve avant le int main(void).
Pourquoi indique-tu en commentaires que "extern" est impossible.

Je préfère ne pas toucher à la forme que me fournit l'IDE.

c'est la solution basique parce que je ne connais pas ce que tu veux faire. Mais je pense que uart donc créer 1 structure pour stocker le handle fournit par le main

Oui dans le main.c a l'initialisation de l'uart on a cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void MX_USART2_UART_Init(void)
{
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 38400;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
 
}

c'est la solution basique parce que je ne connais pas ce que tu veux faire.

Mon but est de pouvoir utiliser la fonction HAL_UART_TRANSMIT.... dans d'autre fichier .c afin d'éclaircir mon code. A l'heure actuelle je ne mettais pas trop pencher sur le sujet et tout est dans le main. Ce n'est pa strrés lisible alors je cherche a apprendre et à m’améliorer.
Mais les pointeurs des strucutres sur focntion etc..... je ne suis pas vraiement à l'aise comme vous pouvez vous en rendre compte, mais j'y travaille

[Bktero]

Si tu veux utiliser une fonction de la HAL de ST dans un fichier .c, il te suffit d'y ajouter #include <stm32f3xx_hal.h>. Tu as constaté qu'il ne fallait pas inclure un fichier spécifique, comme stm32f3xx_hal_usart.h. En effet, ces fichiers spécifiques dépendent de définitions qui sont dans le fichier. Ce fichier commun se charge d'inclure les modules que tu as activé dans le générateur de code de l'IDE STM. Je te laisse fouiller les#includes à l'intérieur de stm32f3xx_hal.h pour comprendre

Oui dans le main.c a l'initialisation de l'uart on a cela :

En ce que, au début de ce fichier, tu as quelque chose comme USART_HandleTypeDef huart2; ? Si oui, alors c'est une variable globale, et tu peux l'utiliser depuis d'autres fichiers .c en y écrivant extern USART_HandleTypeDef huart2;. Je te renvoie à ces 2 entrées de la pour mieux comprendre comment ça fonctionne :

1. https://c.developpez.com/faq/?page=L...fichier-source
2. https://c.developpez.com/faq/?page=G...mbol-not-found

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Je préfère ne pas toucher à la forme que me fournit l'IDE

Si tu codes dans le code généré, il ne faut pas toucher à ce qui est généré. Ton code doit être placé entre les balises prévues (sous peine d'être écrasé à la prochaine génération !) comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
/* USER CODE BEGIN 0 */
// tu peux coder ici
/* USER CODE END 0 */
// mais pas là

[foetus]

Je préfère ne pas toucher à la forme que me fournit l'IDE.

Ce n'est pa strrés lisible alors je cherche a apprendre et à m’améliorer.

D'accord tu codes et lorsque "tu bloques", alors tu agis. Donc, que dire de + : vogue la galère

C'était 1 point très important : les variables globales.
En C, 1 des premiers points qu'on aborde : la visibilité et la portée des variables. locale (dans 1 bloc {}/ fonction), globale (à l'extérieur d' 1 bloc {}/ fonction), extern, static.

Et 1 variable globale, tu peux y accéder de partout : et donc pour tracer/ débugger qui a modifié la variable globale lors d'1 bug/ plantage, cela peut devenir très sport