Sono cattivi? Può essere. Il problema con i globali è che possono essere accessibili e modificati in qualsiasi momento nel tempo da qualsiasi funzione o pezzo di codice in esecuzione, senza restrizioni. Ciò può portare a situazioni, diciamo, difficili da risalire e spiegare. È quindi auspicabile ridurre al minimo la quantità di globuli, se possibile riportare la quantità a zero.
Possono essere evitati? Quasi sempre si. Il problema con Arduino è che ti costringono a questo approccio a due funzioni in cui assumono te setup()e te loop(). In questo caso particolare non hai accesso all'ambito della funzione chiamante di queste due funzioni (probabilmentemain() ). Se lo avessi, potresti sbarazzarti di tutti i globi e utilizzare invece i locali.
Immagina quanto segue:
int main() {
setup();
while (true) {
loop();
}
return 0;
}
Questo è probabilmente più o meno l'aspetto della funzione principale di un programma Arduino. Le variabili necessari sia nella setup()e la loop()funzione di sarebbe poi preferibilmente essere dichiarate all'interno del campo di applicazione della main()funzione piuttosto che la portata globale. Potrebbero quindi essere resi accessibili alle altre due funzioni mediante il loro passaggio come argomenti (usando i puntatori se necessario).
Per esempio:
int main() {
int myVariable = 0;
setup(&myVariable);
while (true) {
loop(&myVariable);
}
return 0;
}
Si noti che in questo caso è necessario modificare anche la firma di entrambe le funzioni.
Poiché ciò potrebbe non essere fattibile o desiderabile, vedo davvero solo un modo per rimuovere la maggior parte dei globuli da un programma Arduino senza modificare la struttura del programma forzato.
Se ricordo bene, sei perfettamente in grado di usare C ++ durante la programmazione per Arduino, piuttosto che C. Se non hai familiarità (ancora) con OOP (Object Oriented Programming) o C ++, potrebbe volerci un po 'di tempo per abituarti e alcuni lettura.
La mia proposta sarebbe quella di creare una classe Program e creare un'unica istanza globale di questa classe. Una classe dovrebbe essere considerata il progetto per gli oggetti.
Considera il seguente programma di esempio:
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à, ci siamo sbarazzati di quasi tutti i globi. Le funzioni in cui inizieresti ad aggiungere la logica dell'applicazione sarebbero le funzioni Program::setup()e Program::loop(). Queste funzioni hanno accesso alle variabili membro specifiche dell'istanza myFirstSampleVariablee mySecondSampleVariablementre le funzioni tradizionali setup()e loop()non hanno accesso in quanto queste variabili sono state contrassegnate come private. Questo concetto si chiama incapsulamento dei dati o occultamento dei dati.
Insegnarti a OOP e / o C ++ è un po 'fuori dalla portata della risposta a questa domanda, quindi mi fermo qui.
Riassumendo: i globi dovrebbero essere evitati ed è quasi sempre possibile ridurre drasticamente la quantità di globi. Anche quando stai programmando per Arduino.
Soprattutto spero che la mia risposta ti sia in qualche modo utile :)