Eles são maus? Talvez. O problema com os globais é que eles podem ser acessados e modificados a qualquer momento, por qualquer função ou parte do código sendo executada, sem restrições. Isso pode levar a situações difíceis, digamos, de rastrear e explicar. Minimizar a quantidade de globais, se possível, trazer a quantidade de volta a zero, é, portanto, desejável.
Eles podem ser evitados? Quase sempre sim. O problema com o Arduino é que eles o forçam a essa abordagem de duas funções, na qual eles assumem você setup()e você loop(). Nesse caso específico, você não tem acesso ao escopo da função de chamada dessas duas funções (provavelmente main()). Se você tivesse, seria capaz de se livrar de todos os globais e usar os habitantes locais.
Imagine o seguinte:
int main() {
setup();
while (true) {
loop();
}
return 0;
}
Provavelmente, isso é mais ou menos o que parece a principal função de um programa Arduino. As variáveis necessárias na função setup()e na loop()função seriam preferencialmente declaradas dentro do escopo da main()função e não no escopo global. Eles poderiam então ser disponibilizados para as outras duas funções, passando-os como argumentos (usando ponteiros, se necessário).
Por exemplo:
int main() {
int myVariable = 0;
setup(&myVariable);
while (true) {
loop(&myVariable);
}
return 0;
}
Observe que, nesse caso, você também precisa alterar a assinatura de ambas as funções.
Como isso pode não ser viável nem desejável, vejo realmente apenas uma maneira de remover a maioria dos globais de um programa Arduino sem modificar a estrutura forçada do programa.
Se bem me lembro, você é perfeitamente capaz de usar C ++ durante a programação do Arduino, em vez de C. Se você ainda não está familiarizado com OOP (Programação Orientada a Objetos) ou C ++, pode levar algum tempo para se acostumar. leitura.
Minha proposta seria criar uma classe de programa e criar uma única instância global dessa classe. Uma classe deve ser considerada o blueprint para objetos.
Considere o seguinte programa de exemplo:
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 livramos de quase todos os globais. As funções nas quais você começaria a adicionar a lógica do aplicativo seriam as funções Program::setup()e Program::loop(). Essas funções têm acesso às variáveis de membro específicas da instância myFirstSampleVariablee, mySecondSampleVariableenquanto as funções setup()e tradicionais loop()não têm acesso, pois essas variáveis foram marcadas como classe privada. Esse conceito é chamado de encapsulamento ou ocultação de dados.
Ensinar a você OOP e / ou C ++ está um pouco fora do escopo da resposta a esta pergunta, então vou parar por aqui.
Resumindo: os globais devem ser evitados e quase sempre é possível reduzir drasticamente a quantidade de globais. Além disso, quando você está programando para o Arduino.
Mais importante ainda, espero que minha resposta seja um pouco útil para você :)