Discussion :

[ROUGEXIII]

Bonjour,

Plus le temps passe, plus mon petit programme pour mon ESP8266 possède de lignes,
assez pour que j'envisage de prendre du temps pour rendre tout cela plus lisible.

Ayant maintenant pris connaissance de la séparation prototypes(.h) VS code(.cpp) je fais quelques tests non concluants.


Avertissement préalable
Afin de ne pas avoir à tout structurer/découper d'un coup je veux avoir recours massivement aux variables globales et même fonctions globales.
... Oui je sais, c'est le mal
Merci de bien vouloir accepter cette orientation et relever le défi tel qu'il est posé



Mon programme de test est découpé comme suis:

• xxx.ino : le code principal setup/loop
• Variables.h : contient les variables GLOBALES
• Fonctions.h : Prototypes des fonctions GLOBALES
• Fonctions.cpp : Fonctions GLOBALES

Ce qui donne:

• xxx.ino :
  

  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
  #include <Arduino.h>
  #include "Variables.h"
  #include "Fonctions.h"
   
  void setup() {
    // put your setup code here, to run once:
    Serial.begin(115200);
  }
   
  void loop() {
    // put your main code here, to run repeatedly:
   
  TexteGlobal="Blabla";
  Fct_Globale(1);
  }

• Variables.h :
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  /* 
   * Variables Globales
   *
   * Variables.h
   */
  #ifndef Variables_h
  #define Variables_h
   
  #include <WString.h>
   
  String TexteGlobal;
   
  #endif

• Fonctions.h :
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
  /* 
   * Fonctions Globales
   *
   * Fonctions.h
   */
   
  #include <WString.h>
   
  String Fct_Globale(int Param_num);

• Fonctions.cpp :
  

  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
  /* 
   * Fonctions Globales
   *
   * Fonctions.cpp
   */
   
  #include <Arduino.h>
  #include "Fonctions.h"
   
  // *****************************************************
  // FONCTION de test
  String Fct_Globale(int Param_num)
  {
    Serial.println(TexteGlobal+Param_num);
    return(TexteGlobal+Param_num);
  }

Alors les problèmes:

1. Pourquoi hors du fichier ino, String n'est-il pas reconnu sans l'appel de WString.h ?
2. Même question avec l'utilisation de Serial dans Fonctions.cpp sans l'appel de Arduino.h
3. Pourquoi ai-je besoin d’appeler Variables.h dans Fonctions.cpp alors qu'il est déjà appelé dans le xxx.ino? Pour le compilateur stupide c'est ça? Pas moyen de rendre Variables.h plus "publique"?
4. Pourquoi si j'appelle à nouveau variables.h dans Fonctions.cpp il trouve la variable définie plusieurs fois même avec #ifndef Variables_h #define #endif autour des variables de Variables.h?
5. Et mêmes questions après quand j'essaye d'appeler des fonctions de Fonctions.h depuis d'autres fichiers.h?

Merci pour votre aide

[Vincent PETIT]

Bonjour à tous,


Pour information :

- Le compilateur est GCC.
- Le fichier .ino et un fichier .c à part entière.
- #include <Arduino.h> est une sorte de #include <stdio.h> et qui contient notamment la fonction Serial qui est l'équivalent de printf.
- L'auteur a peut être besoin d'un éclairage sur la chaîne de compilation (préprocesseur/compilateur/linker) pour comprendre d'où vient le problème d'inclusion multiple et de portée.
- La fonction void setup() est la toute première fonction qui se lance au démarrage du microcontrôleur (bizarrerie de Arduino)
- Dans le fichier .ino, autre bizarrerie, la fonction

Code C :

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

1
2
3
4
5
6
void loop() {
  // put your main code here, to run repeatedly:
 
TexteGlobal="Blabla";
Fct_Globale(1);
}

est a considérer exactement comme un

Code C :

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

1
2
3
4
5
6
7
8
9
10
int main ()
{
   while(1)
   {
      TexteGlobal="Blabla";
      Fct_Globale(1);
   }
 
   return 0;
}

Merci pour lui
Et bonne fête de fin d'année !

Vincent.

[Matt_Houston]

Vincent, oui je suppose que l'éditeur de liens encapsule le code utilisateur dans son propre main pour donner quelque chose comme :

Code :

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

1
2
3
4
5
6
7
int main() {
    setup();
    do
        loop();
    while (1);
    return 0;
}

..rien de déconnant à cela.


Je vois du .cpp, du String.. Attention à ne pas mélanger C et C++, je vais supposer ci-après que l'on est bien en C.

Pourquoi hors du fichier ino, String n'est-il pas reconnu sans l'appel de WString.h ?

Parce que String ne fait nullement partie du langage ? J'imagine que c'est un type fourni par la bibliothèque Arduino..

Même question avec l'utilisation de Serial dans Fonctions.cpp sans l'appel de Arduino.h

Bis repetita.

Pourquoi ai-je besoin d’appeler Variables.h dans Fonctions.cpp alors qu'il est déjà appelé dans le xxx.ino? Pour le compilateur stupide c'est ça? Pas moyen de rendre Variables.h plus "publique"?

En C, les unités de compilation (a.k.a. translation units) sont des modules indépendants.

Pourquoi si j'appelle à nouveau variables.h dans Fonctions.cpp il trouve la variable définie plusieurs fois même avec #ifndef Variables_h #define #endif autour des variables de Variables.h?

Parce que tu définis ta variable dans chaque unité de compilation. Pour qu'une variable soit globale au programme, il faut la déclarer comme suit :

Code global.h :

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

extern int global;

..puis la définir (et éventuellement l'initialiser) dans une et une seule unité de compilation comme suit :

Code global.c :

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

int global = 0;

Et mêmes questions après quand j'essaye d'appeler des fonctions de Fonctions.h depuis d'autres fichiers.h?

Je n'ai pas saisi. Un exemple, peut-être ?

[sambia39]

Bonjour,

Bonjour,

1. Pourquoi hors du fichier ino, String n'est-il pas reconnu sans l'appel de WString.h ?
2. Même question avec l'utilisation de Serial dans Fonctions.cpp sans l'appel de Arduino.h
3. Pourquoi ai-je besoin d’appeler Variables.h dans Fonctions.cpp alors qu'il est déjà appelé dans le xxx.ino? Pour le compilateur stupide c'est ça? Pas moyen de rendre Variables.h plus "publique"?
4. Pourquoi si j'appelle à nouveau variables.h dans Fonctions.cpp il trouve la variable définie plusieurs fois même avec #ifndef Variables_h #define #endif autour des variables de Variables.h?
5. Et mêmes questions après quand j'essaye d'appeler des fonctions de Fonctions.h depuis d'autres fichiers.h?

Merci pour votre aide

1. Tout simplement parce que String est une classe déclarer dans le fichier WString.h donc il est tout à fait normal qu'il faut inclure WString.h pour pouvoirs l'utiliser.
2. C'est pareil que la précédente réponse, de plus Arduino.h apporte tout les sous routines pour I/O.
3. Comme ce qui était évoqué, c'est juste une question de porter de variable.
4. C'est un conflit dû à une redéfinition de la variable tout simplement et idem pour la question cinq.

Vincent, oui je suppose que l'éditeur de liens encapsule le code utilisateur dans son propre main pour donner quelque chose comme :

Code :

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

1
2
3
4
5
6
7
int main() {
    setup();
    do
        loop();
    while (1);
    return 0;
}

..rien de déconnant à cela.


Je vois du .cpp, du String.. Attention à ne pas mélanger C et C++, je vais supposer ci-après que l'on est bien en C.

Oui plus exactement :

Code CPP :

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
 
#include <Arduino.h>
 
int atexit(void (* /*func*/ )()) { 
	return 0; 
}
 
void initVariant() __attribute__((weak));
void initVariant() { }
 
void setupUSB() __attribute__((weak));
void setupUSB() { }
 
int main(void)
{
	init();
 
	initVariant();
 
#if defined(USBCON)
	USBDevice.attach();
#endif
 
	setup();
 
	for (;;) {
		loop();
		if (serialEventRun) serialEventRun();
	}
 
	return 0;
}

Autres points importants, il faut savoir qu'Arduino utilise le C et le langage C++ de façon restreinte donc il ne faut pas comprendre ou ce dire que l'on utilise vraiment le langage C++ avec les règles du standard tel qu'il est défini.
Dans les faits oui, mais dans la réalité non la raison est due au compilateur et le choix est justifié, le microcontrôleur de la carte Arduino n'a pas assez de ressource pour pouvoir supporter certains mécanismes du langage donc il est bridé d'ailleurs il n'y a pas d'allocations dynamiques et autres. De plus, IDE Arduino bride les options du compilateur raison pour laquelle je vous recommande IDE d'Atmel ou voir tout simplement a la mano avr-gcc
À bientôt

[ROUGEXIII]

Bonjour, merci pour vos réponses

Je vois du .cpp, du String.. Attention à ne pas mélanger C et C++, je vais supposer ci-après que l'on est bien en C.

Je suis plutôt débutant mais le C++ c'est bien la possibilité d'utiliser son code orienté objets en plus du langage C?
Donc le C++ inclut le C non?

Parce que String ne fait nullement partie du langage ? J'imagine que c'est un type fourni par la bibliothèque Arduino..

Ma question était plutôt pourquoi le type string est reconnu dans le xxx.ino (main) et non dans les fichiers associés alors que les fichiers associés sont appelés depuis le xxx.ino? Mais du coup je suppose que le point suivant répond à la question.
J'en profite quand même : Quel est le type natif en C qui correspond au string? Il n'y en a pas il faut stocker chaque caractère dans un tableau c'est ça?

En C, les unités de compilation (a.k.a. translation units) sont des modules indépendants.

Donc il faut appeler les fichiers où sont les déclarations dans chaque fichier où on les utilise? Du coup j'espère que le compilateur optimise tout ça et que cela n'augmente pas la place prise en mémoire ou n'influence les performances?
Y a t'-il un autre moyen de découper un gros programme fichier unique pour le rendre plus lisible et maintenable? (hormis la créations de librairies/classes/fonctions propres j’entends, même si c'est le but à terme)

Parce que tu définis ta variable dans chaque unité de compilation. Pour qu'une variable soit globale au programme, il faut la déclarer comme suit :

Code global.h :

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

extern int global;

..puis la définir (et éventuellement l'initialiser) dans une et une seule unité de compilation comme suit :

Code global.c :

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

int global = 0;

J'ai essayé j'obtiens :

Code :

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

1
2
3
4
Archiving built core (caching) in: /tmp/arduino_cache_395619/core/core_esp8266_esp8266_nodemcuv2_CpuFrequency_80,UploadSpeed_115200,FlashSize_4M3M_1cc8b945647fd7aea595b4f6268e0554.a
sketch/YBT_Test_decoupage.ino.cpp.o:(.bss.TexteGlobal+0x0): multiple definition of `TexteGlobal'
sketch/Fonctions.cpp.o:(.bss.TexteGlobal+0x0): first defined here
collect2: error: ld returned 1 exit status

Malgré le

Code :

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

1
2
3
4
5
6
7
#ifndef Variables_h
#define Variables_h
#include <WString.h>
 
extern String TexteGlobal="";
 
#endif

Je n'ai pas saisi. Un exemple, peut-être ?

Je souhaite appeler des fonctions globales contenues dans fonction.cpp depuis d'autres .cpp pas seulement depuis le xxx.ino (main)
mais j'obtiens le même genre d'erreurs que pour les variables globales.

[dalfab]

Je suis plutôt débutant mais le C++ c'est bien la possibilité d'utiliser son code orienté objets en plus du langage C?
Donc le C++ inclut le C non?

Ce sont 2 langages différents. Même s'ils ont des éléments de syntaxe en commun, il est préférable de choisir son langage. Le pire serait d'utiliser le "C avec les classes" qui est une utilisation floue du C++, et finalement on ne connais aucun des 2 langages.

Ma question était plutôt pourquoi le type string est reconnu dans le xxx.ino (main) et non dans les fichiers associés alors que les fichiers associés sont appelés depuis le xxx.ino? Mais du coup je suppose que le point suivant répond à la question.

oui

J'en profite quand même : Quel est le type natif en C qui correspond au string? Il n'y en a pas il faut stocker chaque caractère dans un tableau c'est ça?

C'est justement une différence fondamentale entre le C et le C++.
En C on doit mettre les chaînes de caractères dans des tableaux de char.

Donc il faut appeler les fichiers où sont les déclarations dans chaque fichier où on les utilise? Du coup j'espère que le compilateur optimise tout ça et que cela n'augmente pas la place prise en mémoire ou n'influence les performances?

Le fait de séparer en module n'est pas si coûteux que cela. Le compilateur sait gérer les doublons potentiels (p.e. fonction qui n'a pas été "inlinée" est générée une unique fois, même si existe dans plusieurs modules).

Y a t'-il un autre moyen de découper un gros programme fichier unique pour le rendre plus lisible et maintenable? (hormis la créations de librairies/classes/fonctions propres j’entends, même si c'est le but à terme)

Le découpage en module est le seul moyen. Il est clair,
lisible et maintenable.

J'ai essayé j'obtiens :

Code :

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

1
2
3
4
Archiving built core (caching) in: /tmp/arduino_cache_395619/core/core_esp8266_esp8266_nodemcuv2_CpuFrequency_80,UploadSpeed_115200,FlashSize_4M3M_1cc8b945647fd7aea595b4f6268e0554.a
sketch/YBT_Test_decoupage.ino.cpp.o:(.bss.TexteGlobal+0x0): multiple definition of `TexteGlobal'
sketch/Fonctions.cpp.o:(.bss.TexteGlobal+0x0): first defined here
collect2: error: ld returned 1 exit status

Malgré le

Code :

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

1
2
3
4
5
6
7
#ifndef Variables_h
#define Variables_h
#include <WString.h>
 
extern String TexteGlobal="";
 
#endif

c'est dû au ="", il faut l'enlever car une variable déclarée externe ne peut pas être associée à une initialisation (sinon cela crée une autre instanciation d'où l'erreur). La valeur d’initialisation doit être mise à l'endroit où on définit l'instance

Je souhaite appeler des fonctions globales contenues dans fonction.cpp depuis d'autres .cpp pas seulement depuis le xxx.ino (main)
mais j'obtiens le même genre d'erreurs que pour les variables globales.

Il faut comprendre le rôle des fichiers d'entêtes. Lors de la compilation d'un module, tous les éléments que l'on utilise doivent être identifiés. Pour une variable, il faut au moins connaître son type donc l'entête aura la forme extern int varPartagee;.
Pour une fonction on doit connaître sa signature donc l'entête aura la forme int fonctionPartagee(int,char);, c'est exactement ce que l'on trouve dans la définition avec un ';' au lieu du corps '{}', le nom des paramètres et le mot extern sont facultatifs.
Pour un type, on doit en voir la définition complète s'il est utilisé struct Machin { ... ... }; ou s'il n'est utilisé que par des pointeurs, sa simple existence peut être signalée par struct Machin;

[ROUGEXIII]

Merci pour le retour, nouvel essai, je laisse volontairement les double/tripple/... appels de bibliothèques pour exclure des causes d'erreur potentielles:

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
/* 
 * Main (xxx.ino)
 *
 * 
 */
 
#include <WString.h>
#include "Variables.h"
#include "Fonctions.h"
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
}
 
void loop() {
  // put your main code here, to run repeatedly:
 
TexteGlobal="Blabla";
Fct_Globale(1);
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
/* 
 * Variables Globales
 *
 * Variables.h
 */
//#ifndef Variables_h
//#define Variables_h
#include <WString.h>
 
extern String TexteGlobal;
 
//#endif

Code :

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

1
2
3
4
5
6
7
8
9
10
/* 
 * Variables Globales
 *
 * Variables.c
 */
 
#include <WString.h>
#include "Variables.h"
 
String TexteGlobal=" ";

Code :

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

1
2
3
4
5
6
7
8
9
/* 
 * Fonctions Globales
 *
 * Fonctions.h
 */
 
#include <WString.h>
 
extern String Fct_Globale(int Param_num);

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
/* 
 * Fonctions Globales
 *
 * Fonctions.c
 */
 
#include <Arduino.h>
#include <WString.h>
#include "Variables.h"
#include "Fonctions.h"
 
 
// *****************************************************
// FONCTION de test
String Fct_Globale(int Param_num)
{
  Serial.println(TexteGlobal+Param_num);
  return(TexteGlobal+Param_num);
}

Mais voici les erreurs:

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
In file included from sketch/Fonctions.c:9:0:
Variables.h:10: error: unknown type name 'String'
 extern String TexteGlobal;
 ^
In file included from sketch/Fonctions.c:10:0:
Fonctions.h:9: error: unknown type name 'String'
 extern String Fct_Globale(int Param_num);
 ^
Fonctions.c:15: error: unknown type name 'String'
 String Fct_Globale(int Param_num)
 ^
sketch/Fonctions.c: In function 'Fct_Globale':
Fonctions.c:17: error: 'Serial' undeclared (first use in this function)
   Serial.println(TexteGlobal+Param_num);
   ^
sketch/Fonctions.c:17:3: note: each undeclared identifier is reported only once for each function it appears in
exit status 1
unknown type name 'String'

[dalfab]

J'ai l'impression que tu as mélangé du C et du C++. Ce code ne peut pas fonctionner en C, donc tes fichiers doivent terminer par .cpp au lieu de .c

[ROUGEXIII]

J'ai l'impression que tu as mélangé du C et du C++. Ce code ne peut pas fonctionner en C, donc tes fichiers doivent terminer par .cpp au lieu de .c

En effet... une fois les deux fichier .c renommés en .cpp cela fonctionne
Suite au commentaire de Matt_Houston je pensais être en c, mais je dois pas encore être au point...

Du coup c'est parti pour le découpage de mon gros programme:

• xxx.ino
• IO.h : contient les entrées/sorties
• IO.cpp : contient les initialisation des entrées/sorties
• Variables.cpp : contient les initialisation des variables GLOBALES
• Variables.h : contient les variables GLOBALES
• Variables.cpp : contient les initialisation des variables GLOBALES
• Fonctions.h : Prototypes des fonctions GLOBALES
• Fonctions.cpp : Fonctions GLOBALES

Je suis obligé de créer le .h de chaque .cpp pour les variables et les entrées/sorties? Parceque du coup ça double le code à taper, d'un côté on déclare de l'autre on initie... ça améliore pas la lisibilité/maintenabilité.

[dalfab]

Le problème de lisibilité/maintenabilité sera surtout dû a : "relis le titre de ton post"