Variables

Una variable es una manera de nombrar y almacenar un valor para su uso posterior por el programa. Como su nombre indica, las variables son valores que se pueden variar continuamente en contra de lo que ocurre con las constantes cuyo valor nunca cambia. Una variable debe ser declarada y opcionalmente, asignarle un valor.

[alcance] tipo nombre [= valor];

Antes de que se usada, todas las variables deben declararse. Declarar una variable significa definir el tipo de dato que soportara y opcionalmente establecer un valor inicial.

Los posibles alcances son static, global o local.

• Tipos
• Ambito
• const
• static
• Matrices
• struct
• enum
• typedef
• union
• Punteros
• Volatil

1. Tipos

Los tipos de variables están descritos en los tipo de datos que soporta Arduino. El tipo determina la capacidad de almacenamiento. Cuando una variable excede su capacidad máxima pasa a su valor mínimo y vicevesa.

//Byte
byte n = 100;
//Enteros
int n = 1234;
int m = B1111011; //binario
int p = 0x7B; //Hexadecimal
//Punto flotante
float n = 0.005;
float m = 2.34E5; //234000
float p = 67e-12; //0.000000000067

Tenga cuidado con sobrepasar los limites del tipo de dato.

int x = -31768;
x--; //32,767
int n = 35767;
n++; //-32,768

2. Ambito

Una variable global es una variable que puede ser vista por cada función en un programa. Las variables locales son accesibles solamente a la función en la que se declaran.

int n;  //Variable global
void setup(){
	inx x;
}
void loop(){
	int y;
}

A veces también es útil declarar e inicializar una variable dentro de un bucle. Esto crea una variable que sólo se puede acceder desde el interior de las llaves del bucle.

3. const

Son variables que no cambian de valor. Las constantes enteras son números que se usan directamente en un boceto, como 123. De forma predeterminada, estos números se tratan como int, pero puede cambiar esto con los modificadores U (unsigned) y L (long).

const (tipo) nombre[=valor];

const 33U      //unsigned int
const 9L       //long
const 32189UL  //unsigned long

Normalmente, las constantes enteras se tratan como enteros base 10 (decimales), pero se puede usar notación especial (formateadores) para ingresar números en otras bases.

Una diferencia importante entre usar const o no es que al usarla la variable es almacenada en la memoria flash en lugar de la escasa RAM.

4. Static

La palabra clave static se usa para crear variables que solo son visibles dentro de una función. Sin embargo a diferencia de las variables locales que se crean y destruyen cada vez que se invoca una función, las variables estatic persisten más allá de la llamada a la función, preservan sus datos entre llamadas a funciones. Las variables declaradas como static sólo se crean e inicializan la primera vez que una función es llamada.

static variable[=valor];

Un ejemplo muy interesante que te gustaría analizar es:

byte n = 100;
void setup(){
	Serial.begin(9600);
}
void loop(){
	Serial.print("Contador general = ");
	Serial.println(n++);
	contador1();
	contador2();
}
void contador1(){
	static byte n = 0;
	Serial.print("Contador 1 = ");
	Serial.println(n++);
}
void contador2(){
	static byte n = 255;
	Serial.print("Contador 2 = ");
	Serial.println(n--);
}

5. Matrices

Es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice. El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0. Un matriz tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser usado.

tipo nombre[] = {val1, val2, ...};
tipo nombre[n];
nombre[0] = val1;

Algunos ejemplo de matrices son

char vocales[6] = {'a','e','i','o','u'}; //Debes poner un espacio al final para \0 ver char
char palabra[15] = "Arduino";
char saludo[] = "Hola mundo";
byte pares[] = {2,4,6,8};

6. struct

7. enum

Durante el diseño de un sistema nos podemos encontrar en la situación de determinar una variable numérica a la cual le asignamos valores arbitrarios con un significado asociado, que si no documentamos en ese momento luego seguramente no nos acordaremos mas del significado de dichos valores. El modificador enum nos permite asignar palabras mas significativas a cada numero.

//0=junior, 1=sub23, 2=elite; 3=master, 4=senior
enum tipoCategoria {junior, sub23, elite, master, senior} categoria = elite;
if (categoria == elite){
	//Hacer algo
}

Desventajas: Es importante anotar que aunque este tipo de dato internamente está usando un entero, no admite ser tratado como tal, por lo que no podremos usarlo de formas como: categoria=2; categoria++

8. typedef

9. union

10. Punteros

Almacena la dirección de memoria donde esta el dato (2 bytes).

11. Volatil

Esto le dice al compilador que la variables pueden cambiar en cualquier momento, por lo que el compilador debe volver a cargar la variable cada vez que la referencia, en lugar de depender de una copia que pueda tener en un registro de procesador. Las variables compartidas entre las funciones ISR y las funciones normales deben declararse volatil. Volatile es una palabra clave calificadora.

volatile (tipo) nombre[=valor];

Las variables de este tipo se guardan en RAM no en el registro de almacenamiento como las demás.

//Conmuta un LED cuando una interrupción cambia el estado de un pin
volatile bool estado = LOW;
void setup(){
  pinMode(13, OUTPUT);
  attachInterrupt(0, parpadea, CHANGE);
}
void loop(){
  digitalWrite(13, estado);
}
void parpadea(){
  estado = !estado;
}