Variables static en Arduino, variables globales y ámbito
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Una variable creada dentro de una función empieza de nuevo cada vez que la función se ejecuta y desaparece cuando regresa. Ponle static delante y se crea una sola vez, conserva su valor entre llamadas y aun así solo puede verse dentro de esa función. Una variable global, creada fuera de toda función, también conserva su valor, pero todas las funciones del sketch pueden verla y cambiarla.
El circuito de arriba es el banco de código, cuyo sketch imprime sus variables globales por nombre, como "lampCount = 3", y luego muestra un número que no cabe en su tipo: "32000 + 1000 in an int = -32536". Las globales así son la forma habitual de conservar un valor entre pasadas de loop(); una static suele ser la más ordenada.
Abajo hay una static dentro de una función y dentro de loop(), la global que nunca cambia, el error de ámbito y cómo una global se comparte entre pestañas con extern.
¿Quieres la versión paso a paso? La lección "Las variables tienen un tamaño" recorre esto con puntos de control.
Abrir la lecciónstatic conserva su valor entre llamadas
Las dos funciones de abajo son iguales salvo por una palabra. Llamadas tres veces cada una, countLocal() imprimió "local 1" cada vez, porque su n se crea de nuevo y se pone en 0 en cada llamada. countStatic() imprimió "static 1", "static 2" y "static 3": su n se puso en 0 una sola vez, la primera, y siguió contando.
El = 0 de una static se ejecuta una vez. Esa es la parte que sorprende: la línea parece reiniciar el conteo y no lo hace.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
static dentro de loop()
loop() es una función como cualquier otra, así que una variable común en ella se pierde al final de cada pasada. Un temporizador con millis() necesita que su último tiempo sobreviva, y por eso los tutoriales lo ponen al inicio del sketch. Una static en loop() también sobrevive y mantiene el nombre junto al único código que lo usa.
El sketch de abajo imprimió "tick 1 at 1000", "tick 2 at 2000" y "tick 3 at 3000". Con static borrado de ambas líneas, imprimió "tick 1 at 1000" y luego "tick 1" otra vez en cada pasada: last vuelve a ser 0 cada vez, así que después del primer segundo la prueba siempre es verdadera y ticks también empieza de 0 otra vez.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
La variable global que nunca cambia
Cuando una global no cambia, busca una segunda variable con el mismo nombre. En el sketch de abajo, int total = 0; dentro de addReading() crea una nueva total local que oculta la global. La función suma a la copia local, que se descarta cuando regresa, así que tras tres llamadas el sketch imprimió "total is 0". Borra el int total = 0; de dentro de la función e imprimió "total is 15".
Ni clang ni GCC avisan de esto por defecto. La pista es un nombre de tipo delante de una variable que querías usar, no crear.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Ámbito: dónde se puede ver un nombre
Una variable creada entre dos llaves existe solo entre ellas. int ledPin = 13; dentro de setup() no puede usarse en loop(), y la compilación se detuvo con use of undeclared identifier 'ledPin'. El GCC del IDE de Arduino dice 'ledPin' was not declared in this scope. Mueve la línea arriba de setup(), fuera de ambas funciones, y las dos podrán verla.
Lo mismo pasa con una variable creada dentro de un if o de un for: desaparece tras la llave de cierre. Eso es útil, porque un nombre usado en un solo lugar no puede cambiarse por accidente en otra parte, y es la razón para preferir una static o una local en lugar de una global cuando solo una función necesita el valor.
Una global entre pestañas: extern
Un sketch con una segunda pestaña, counter.cpp, necesita que esa pestaña y el sketch compartan una variable. Créala en exactamente un archivo .cpp y declárala con extern en un header que ambos incluyan. El proyecto de abajo imprimió "presses = 3".
Dos errores son comunes. Crear la variable en el header, `int presses = 0;`, la crea una vez en cada archivo que lo incluye, y la compilación se detiene en el enlace con duplicate symbol: presses (el enlazador de GCC dice multiple definition of `presses'). Ponerla como `static int presses = 0;` en el header compila, y es peor: cada archivo tiene su propia copia privada, así que el contador contó en una y el sketch imprimió la otra, "presses = 0". static en una global significa "solo este archivo".
// 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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
static, global, volatile y RAM
Una variable que una interrupción cambia necesita también volatile, sea global o static, para que loop() la lea fresca cada vez en lugar de conservar una copia antigua. Las static y las globales viven ambas en los 2048 bytes de RAM del Uno durante toda la ejecución y cuentan en la cifra "Global variables use" que el IDE de Arduino imprime tras una compilación; las locales usan la pila solo mientras su función se ejecuta. Un arreglo grande que solo una función necesita, solo mientras se ejecuta, es mejor hacerlo local.
Abre este circuito en el editor. Arduino Uno: el banco de código, imprimiendo sus variables, cableado como se ejecuta al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Qué significa static en una variable de Arduino?
Dentro de una función, static crea la variable una sola vez, conserva su valor entre llamadas y la mantiene privada de esa función. Fuera de toda función, static hace que una global sea privada de su propio archivo.
¿Debo usar una variable static o una variable global?
Usa una static en la función cuando solo esa función necesita el valor, como el último tiempo de un temporizador en loop(). Usa una global cuando varias funciones, o una interrupción, necesitan compartirla.
¿Por qué no cambia mi variable global de Arduino?
Normalmente una local con el mismo nombre la oculta: un nombre de tipo delante, como int total = 0; dentro de una función, crea una variable nueva. Quita el tipo para usar la global. Si una interrupción la cambia, hazla también volatile.
Does static int n = 0; reset n to zero each time?
No. El valor después del = se asigna una sola vez, la primera vez que la función se ejecuta. Cada llamada posterior continúa desde el último valor.
¿Cómo uso una variable global en otra pestaña?
Créala en un archivo .cpp, int presses = 0;, y pon extern int presses; en un header que incluya cada pestaña que la use.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.