Sont-ils mauvais? Peut être. Le problème avec les globaux est qu'ils peuvent être consultés et modifiés à tout moment par n'importe quelle fonction ou morceau de code en cours d'exécution, sans restrictions. Cela peut conduire à des situations qui sont, disons, difficiles à retracer et à expliquer. Il est donc souhaitable de minimiser la quantité de globaux, si possible de ramener la quantité à zéro.
Peut-on les éviter? Presque toujours oui. Le problème avec Arduino est qu'ils vous forcent dans cette approche à deux fonctions dans laquelle ils vous supposent setup()et vous loop(). Dans ce cas particulier, vous n'avez pas accès à l'étendue de la fonction appelant de ces deux fonctions (probablement main()). Si vous l'aviez fait, vous seriez en mesure de vous débarrasser de tous les globaux et d'utiliser plutôt des locaux.
Imaginez ce qui suit:
int main() {
setup();
while (true) {
loop();
}
return 0;
}
C'est probablement plus ou moins à quoi ressemble la fonction principale d'un programme Arduino. Les variables dont vous avez besoin à la fois dans setup()la loop()fonction et dans la fonction seraient alors de préférence déclarées à l'intérieur de la portée de la main()fonction plutôt que de la portée globale. Ils pourraient alors être rendus accessibles aux deux autres fonctions en les passant comme arguments (en utilisant des pointeurs si nécessaire).
Par exemple:
int main() {
int myVariable = 0;
setup(&myVariable);
while (true) {
loop(&myVariable);
}
return 0;
}
Notez que dans ce cas, vous devez également modifier la signature des deux fonctions.
Comme cela pourrait ne pas être faisable ni souhaitable, je ne vois vraiment qu'une seule façon de supprimer la plupart des globaux d'un programme Arduino sans modifier la structure du programme forcé.
Si je me souviens bien, vous êtes parfaitement capable d'utiliser C ++ lors de la programmation pour Arduino, plutôt que C. Si vous n'êtes pas (encore) familier avec OOP (Object Oriented Programming) ou C ++, cela pourrait prendre un certain temps pour s'y habituer et d'autres en train de lire.
Ma proposition serait de créer une classe Program et de créer une seule instance globale de cette classe. Une classe doit être considérée comme le modèle des objets.
Considérez l'exemple de programme suivant:
class Program {
public:
Program();
void setup();
void loop();
private:
int myFirstSampleVariable;
int mySecondSampleVariable;
};
Program::Program() :
myFirstSampleVariable(0),
mySecondSampleVariable(0)
{
}
void Program::setup() {
// your setup code goes here
}
void Program::loop() {
// your loop code goes here
}
Program program; // your single global
void setup() {
program.setup();
}
void loop() {
program.loop();
}
Voilà, nous nous sommes débarrassés de presque tous les mondiaux. Les fonctions dans lesquelles vous commenceriez à ajouter votre logique d'application seraient les fonctions Program::setup()et Program::loop(). Ces fonctions ont accès aux variables membres spécifiques à l'instance myFirstSampleVariableet mySecondSampleVariablealors que les fonctions traditionnelles setup()et loop()n'ont pas accès car ces variables ont été marquées class private. Ce concept est appelé encapsulation ou masquage de données.
Vous enseigner la POO et / ou le C ++ est un peu hors de portée de la réponse à cette question, je vais donc m'arrêter ici.
Pour résumer: les globaux doivent être évités et il est presque toujours possible de réduire considérablement le nombre de globaux. Aussi lorsque vous programmez pour Arduino.
Plus important encore, j'espère que ma réponse vous sera quelque peu utile :)