¿Son malvados? Tal vez. El problema con los globales es que se puede acceder a ellos y modificarlos en cualquier momento mediante cualquier función o código que se ejecute, sin restricciones. Esto puede conducir a situaciones que son, digamos, difíciles de rastrear y explicar. Por lo tanto, es deseable minimizar la cantidad de glóbulos, si es posible volver a poner la cantidad a cero.
¿Se pueden evitar? Casi siempre si. El problema con Arduino es que te obligan a adoptar este enfoque de dos funciones en el que te asumen a ti setup()y a ti loop(). En este caso particular, no tiene acceso al alcance de la función de llamada de estas dos funciones (probablemente main()). Si lo hubiera hecho, podría deshacerse de todos los globales y utilizar a los locales en su lugar.
Imagen de lo siguiente:
int main() {
setup();
while (true) {
loop();
}
return 0;
}
Esto es probablemente más o menos como se ve la función principal de un programa Arduino. Entonces, las variables que necesita tanto en setup()la loop()función como en la función se declararían preferiblemente dentro del alcance de la main()función en lugar del alcance global. Luego podrían hacerse accesibles a las otras dos funciones pasándolas como argumentos (utilizando punteros si es necesario).
Por ejemplo:
int main() {
int myVariable = 0;
setup(&myVariable);
while (true) {
loop(&myVariable);
}
return 0;
}
Tenga en cuenta que en este caso también necesita cambiar la firma de ambas funciones.
Como esto podría no ser factible ni deseable, realmente veo solo una forma de eliminar la mayoría de los globales de un programa Arduino sin modificar la estructura del programa forzado.
Si no recuerdo mal, puede usar C ++ perfectamente mientras programa para Arduino, en lugar de C. Si aún no está familiarizado (todavía) con OOP (Programación Orientada a Objetos) o C ++, puede tomar un tiempo acostumbrarse y algunos leyendo.
Mi propuesta sería crear una clase de Programa y crear una única instancia global de esta clase. Una clase debe considerarse el modelo para los objetos.
Considere el siguiente programa de ejemplo:
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à, nos hemos librado de casi todos los globales. Las funciones en las que comenzaría a agregar la lógica de su aplicación serían las funciones Program::setup()y Program::loop(). Estas funciones tienen acceso a las variables miembro específicas de la instancia myFirstSampleVariabley mySecondSampleVariablemientras que las funciones tradicionales setup()y loop()no tienen acceso ya que estas variables se han marcado como privadas de clase. Este concepto se llama encapsulación de datos u ocultación de datos.
Enseñarle OOP y / o C ++ está un poco fuera del alcance de la respuesta a esta pregunta, así que me detendré aquí.
Para resumir: se deben evitar los globals y casi siempre es posible reducir drásticamente la cantidad de globals. También cuando estás programando para Arduino.
Lo más importante es que espero que mi respuesta sea algo útil para usted :)