Arduino: variáveis static, variáveis globais e escopo
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
Uma variável criada dentro de uma função começa de novo toda vez que a função roda, e desaparece quando ela retorna. Coloque static na frente dela e ela passa a ser criada uma única vez, mantém seu valor entre chamadas e ainda só pode ser vista dentro daquela função. Uma variável global, criada fora de todas as funções, também mantém seu valor, mas todas as funções do sketch podem vê-la e alterá-la.
O circuito acima é a bancada de código, cujo sketch imprime suas variáveis globais pelo nome, como "lampCount = 3", e depois mostra um número que não cabe no seu tipo: "32000 + 1000 in an int = -32536". Globais como essas são o jeito mais comum de guardar um valor entre passagens de loop(); uma static costuma ser o mais organizado.
Abaixo estão static dentro de uma função e dentro de loop(), a global que nunca muda, o erro de escopo, e como uma global é compartilhada entre abas com extern.
Quer a versão passo a passo? A aula "Variáveis têm um tamanho" percorre tudo isso com checkpoints.
Abrir a aulastatic mantém seu valor entre chamadas
As duas funções abaixo são iguais, exceto por uma palavra. Chamadas três vezes cada, countLocal() imprimiu "local 1" todas as vezes, porque seu n é criado de novo e definido como 0 em cada chamada. countStatic() imprimiu "static 1", "static 2" e "static 3": seu n foi definido como 0 uma única vez, na primeira, e continuou contando.
O = 0 em uma static roda uma vez. Essa é a parte que surpreende as pessoas: a linha parece zerar a contagem, mas não é isso que ela faz.
void countLocal() {
int n = 0;
n++;
Serial.print("local ");
Serial.println(n);
}
void countStatic() {
static int n = 0;
n++;
Serial.print("static ");
Serial.println(n);
}
void setup() {
Serial.begin(9600);
for (int i = 0; i < 3; i++) {
countLocal();
countStatic();
}
}
void loop() {
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
static dentro de loop()
A função loop() é uma função como qualquer outra, então uma variável comum dentro dela é perdida no fim de cada passagem. Um timer com millis() precisa que o último tempo sobreviva, e é por isso que os tutoriais colocam essa variável no topo do sketch. Uma variável static em loop() também sobrevive, e mantém o nome perto do único código que a usa.
O sketch abaixo imprimiu "tick 1 at 1000", "tick 2 at 2000" e "tick 3 at 3000". Com o static apagado das duas linhas, ele imprimiu "tick 1 at 1000" e depois "tick 1" de novo a cada passagem: last volta a ser 0 todas as vezes, então depois do primeiro segundo o teste é sempre verdadeiro, e ticks também começa de novo do 0.
void setup() {
Serial.begin(9600);
}
void loop() {
static unsigned long last = 0;
static int ticks = 0;
if (millis() - last >= 1000) {
last = millis();
ticks++;
Serial.print("tick ");
Serial.print(ticks);
Serial.print(" at ");
Serial.println(last);
}
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
A variável global que nunca muda
Quando uma global não muda, procure uma segunda variável com o mesmo nome. No sketch abaixo, int total = 0; dentro de addReading() cria uma nova variável total local que esconde a global. A função soma na cópia local, que é jogada fora quando ela retorna, então após três chamadas o sketch imprimiu "total is 0". Apague o int total = 0; de dentro da função e ele imprimiu "total is 15".
Nem o clang nem o GCC avisam sobre isso por padrão. O sinal característico é um nome de tipo na frente de uma variável que você queria usar, e não criar.
int total = 0;
void addReading(int value) {
int total = 0;
total = total + value;
}
void setup() {
Serial.begin(9600);
addReading(5);
addReading(5);
addReading(5);
Serial.print("total is ");
Serial.println(total);
}
void loop() {
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Escopo: onde um nome pode ser visto
Uma variável criada entre duas chaves existe apenas entre elas. int ledPin = 13; dentro de setup() não pode ser usada em loop(), e a compilação parou com use of undeclared identifier 'ledPin'. O GCC do Arduino IDE diz 'ledPin' was not declared in this scope. Mova a linha para acima de setup(), fora das duas funções, e as duas poderão vê-la.
O mesmo vale para uma variável criada dentro de um if ou de um for: ela desaparece depois da chave de fechamento. Isso é útil, porque um nome usado em um só lugar não pode ser alterado por acidente em outro, e é o motivo para preferir uma static ou uma local em vez de uma global quando só uma função precisa do valor.
Uma global entre abas: extern
Um sketch com uma segunda aba, counter.cpp, precisa que essa aba e o sketch compartilhem uma variável. Crie-a em exatamente um arquivo .cpp e declare-a com extern em um header que os dois incluam. O projeto abaixo imprimiu "presses = 3".
Dois erros são comuns. Criar a variável no header, `int presses = 0;`, cria uma cópia em cada arquivo que o inclui, e a compilação para no link com duplicate symbol: presses (o linker do GCC diz multiple definition of `presses'). Declará-la como `static int presses = 0;` no header compila, e é pior: cada arquivo ganha sua própria cópia privada, então o contador somou em um arquivo e o sketch imprimiu o outro, "presses = 0". static em uma global significa "somente este arquivo".
// counter.h
#pragma once
extern int presses;
void countPress();
// counter.cpp
#include "counter.h"
int presses = 0;
void countPress() {
presses++;
}
// sketch.ino
#include "counter.h"
void setup() {
Serial.begin(9600);
countPress();
countPress();
countPress();
Serial.print("presses = ");
Serial.println(presses);
}
void loop() {
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
static, global, volatile e RAM
Uma variável que uma interrupção altera também precisa de volatile, seja global ou static, para que loop() a leia atualizada a cada vez, em vez de guardar uma cópia antiga. Variáveis static e globais ficam nos 2048 bytes de RAM do Uno durante toda a execução e entram no número "Global variables use" que o Arduino IDE imprime depois de uma compilação; as locais usam apenas a pilha enquanto suas funções executam. Um array grande que só uma função precisa, e só enquanto executa, é melhor como local.
Abra este circuito no editor. Arduino Uno: a bancada de código, imprimindo suas variáveis, ligado conforme roda no topo desta página. Troque um componente ou um valor e rode de novo.
Perguntas
O que static significa em uma variável do Arduino?
Dentro de uma função, static cria a variável uma única vez, mantém seu valor entre chamadas e a mantém privada daquela função. Fora de todas as funções, static torna uma global privada do próprio arquivo.
Devo usar uma variável static ou uma variável global?
Use uma static dentro da função quando só ela precisa do valor, como o último tempo de um timer em loop(). Use uma global quando várias funções, ou uma interrupção, precisam compartilhar o valor.
Por que minha variável global do Arduino não muda?
Geralmente uma local com o mesmo nome a esconde: um nome de tipo na frente, como int total = 0; dentro de uma função, cria uma variável nova. Remova o tipo para usar a global. Se uma interrupção a altera, deixe-a também volatile.
Does static int n = 0; reset n to zero each time?
Não. O valor depois do = é definido uma única vez, na primeira vez que a função executa. Cada chamada seguinte continua do último valor.
Como uso uma variável global em outra aba?
Declare-a em um arquivo .cpp com int presses = 0;, e coloque extern int presses; em um header que toda aba que a use inclua.
Continuar
De onde vêm as informações desta página
Monte isto de verdade
Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.