TIPOS DE VARIABLES

1.- BOOLEAN
Solo pueden tener 2 valores: cierto, TRUE (1 o todo lo que sea distinto de 0) y falso, FALSE (0).
boolean mivariable1 = true; boolean mivariable1 = 1;

2.- CHAR
Las variables pueden tener solo un caracter (letra, digito, signo de puntuacion, etc.) escrito entre comillas simples, char
mivariable1 = ‘A’. Son reconocidos por Arduino como números según la tabla ASCII. A = 65 por lo que A+1 = 65;
Cada variable de este tipo ocupa 8 bits (1 byte) de memoria para almacenar su valor. Implica 2exp8 = 256 posibles valores
según el rango -2exp7= -128 a 2exp7-1= 127.

3.- BYTE
El valor de esta variable será siempre un número entero entre 0 y 255. Igual que las tipo char utilizan un byte (8 bits) para
almacenar su valor pero a diferencia de esta no pueden sus valores ser negativos. Implica 2exp8 =256 (0-255)

4.- INT
El valor de esta variable es un número entero, utilizando 2 bytes (16 bits) de memoria lo que implica -2exp15 = -32768 y
2exp15-1=32767. En la “due” utiliza 4 bytes (32 bits) de memoria lo que implica de -2exp31 a 2exp31 -1.

5.- WORD
Es una variable que solo admite números enteros. Ocupa 2 bytes(16bits) de memoria. Implica 2exp16= 65536 valores (0-
65535). Salvo la que se utiliza en la placa “due”. Ocupan 4 bytes(32 bits) como las Int, pero sus valores no pueden ser
negativos. Implica 2exp32 o sea entre 0-4.294.967.295

6.-SHORT
Las variables short son equivalentes a las int salvo en las placas “due” que contaban con las int de 4 bytes(32 bits) y con las
short se dispone de 2 bytes(16 bits).

7.- LONG
El valor de estas variables es un número entero utilizando 4 bytes (32 bits) de memoria para almacenarse, admitiendo
negativos y positivos. Desde -2exp31 a 2exp31-1

8.-UNSIGNED LONG
El valor que puede tomar esta variable es un número entero, no negativos utilizando 4 bytes (32 bits) para almacenarse. Esto
es 2exp32 (0-4.294.967.295. En algún modo es equivalente a Word.

9.- FLOAT
El valor de esta variable es un número decimal. Sus valores pueden ir de -3,4028235 * 10exp38 hasta 3,4028235 * 10 exp 38.
Debido a su grndísimo rango de valores posibles, los números decimales son usados frecuentemente para aproximar valores
analógicos continuos. No obstante solo tienen 6 0 7 dígitos en total de ptecisión. Es decir, los valores “float” no son exactos, y
pueden producir resultados inesperados como por ejemplo que 6.0 / 3.0 no dé exactamente 2.0. A su vez el cálculo
matemático con ellos es mucho más lento que con valores enteros.

10.- DOUBLE
Es un sinónimo exactamente equivalente del tipo float y por tanto no aporta ningún aumento de precisión. Como la float
ocupa 4 bytes (32 bits) de memoria.

11.- ARRAY
este tipo de datos en realidad no existe como tal. Lo que existen son arrays de variables de tipo “boolean”, arrays de variables
de tipo “int”, arrays de variables de tipo “float”, etc. En definitiva: arrays de variables de cualquier tipo de los mencionados
hasta ahora. Un array (también llamado “vector”) es una colección de variables de un tipo concreto que tienen todas el mismo
y único nombre, pero que pueden distinguirse entre sí por un número a modo de índice. Es decir: en vez de tener diferentes
variables –por ejemplo de tipo “char” – cada una independiente de las demás (varChar1, varChar2,varChar3...) podemos
tener un único array que las agrupe todas bajo un mismo nombre (por ejemplo, varChar), y que permita que cada variable
pueda manipularse por separado gracias a que dentro del array cada una está identificada mediante un índice numérico,
escrito entre corchetes (varChar[0], varChar[1], varChar[2]...). Los arrays sirven para ganar claridad y simplicidad en el
código, además de facilitar la programación.
Podemos crear –declarar– un array (ya sea en la zona de declaraciones globales o bien dentro de alguna sección concreta),
de las siguientes maneras:

Hay que tener en cuenta que el primer valor del array tiene el índice 0 y por tanto, el último valor tendrá un índice igual al
número de elementos del array menos uno. Cuidado con esto, porque asignar valores más allá del número de elementos
declarados del array es un error. En concreto, si por ejemplo tenemos un array de 2 elementos de tipo entero (es decir,
declarado así: int varInt[2]; ), para asignar un nuevo valor (por ejemplo, 27) a su primer elemento deberíamos escribir:
varInt[0] = 27; , y para asignar el segundo valor (por ejemplo, 17), escribiríamosvarInt[1] = 17; . Pero si asignáramos además
un tercer valor así, varInt[2] = 53; , cometeríamos un error porque estaríamos sobrepasando el final previsto del array (y por
tanto, utilizando una zona de la memoria no reservada, con resultados imprevisibles).

Por otro lado, además de asignar a un elemento de un array un valor explícito tal como se acaba de comentar en el párrafo
anterior, también es posible asignar a un elemento de un array el valor que tenga en ese momento otra variable
independiente (preferiblemente del mismo tipo). Por ejemplo, mediante la línea varInt[4]=x; estaremos asignando el valor
actual de una variable llamada “x” al quinto elemento (¡el índice empieza por 0!) del array llamado “varInt”. Y a la inversa
también es posible: para asignar el valor que tenga en ese momento el quinto elemento del array “varInt” a la variable
independiente “x”, simplemente deberemos ejecutar la línea: x=varInt[4];
En el caso concreto de los arrays de caracteres (las “cadenas” o “strings”), hay que tener en cuenta una particularidad muy
importante: este tipo de arrays siempre deben ser declarados con un número de elementos una unidad mayor que el número
máximo de caracteres que preveamos guardar. Es decir, si se va a almacenar la palabra “hola” (de cuatro letras), el array
deberá ser declarado como mínimo de 5 elementos. Esto es así porque este último elemento siempre se utiliza para
almacenar automáticamente un carácter especial (el carácter “nulo”, con código ASCII 0), que sirve para marcar el final de la
cadena. Esta marca es necesaria para que el compilador sepa que la cadena ya terminó y no intente seguir leyendo más
posiciones. Si no sabemos de antemano cuál es la longitud del texto que se guardará en un array de caracteres, podemos
declarar este con un número de elementos lo suficientemente grande como para que haya elementos sin ser asignados, aun
sabiendo que así posiblemente estaremos desaprovechando memoria del microcontrolador.

Finalmente, comentar que a menudo es conveniente, cuando se trabaja con grandes cantidades de texto (por ejemplo, en un
proyecto con pantallas LCD), utilizar arrays de strings. Para declarar un array de esta clase, se utiliza el tipo de datos especial
“char*” (notar el asterisco final). Un ejemplo de declaración e inicialización de este tipo sería: char*
varCadenas[]={"Cad0","Cad1","Cad2","Cad3"};. En realidad, el asterisco en la declaración anterior indica que en realidad
estamos declarando un array de “punteros”, ya que para el lenguaje Arduino, las cadenas son punteros. Los “punteros” son
unos elementos del lenguaje Arduino (provenientes del lenguaje C en el que está basado) muy potentes pero a la
vezciertamente complejos. En este libro no se tratarán, debido a que sus posibles usos son avanzados y pueden confundir al
lector que se inicia en la programación: lo único que necesitaremos saber es cómo se declaran los arrays de cadenas y nada
más. La buena noticia es que, una vez declarado el array de cadenas, podemos trabajar con él (asignando valores a sus
elementos, consultándolos, etc.) como cualquier otro tipo de array sin notar para nada que estamos usando punteros.

CONSTANTES

Es posible declarar una variable de tal forma que consigamos que su valor (del tipo que sea) permanezca siempre inalterado.
Es decir, que su valor no se pueda modificar nunca porque esté marcado como de “solo lectura”. De hecho, a este tipo de
variables ya no se les llama así por motivos obvios, sino “constantes”. Las constantes se pueden utilizar como cualquier
variable de su mismo tipo, pero si se intenta cambiar su valor, el compilador lanzará un error.

Para convertir una variable (sea global o local) en constante, lo único que hay que hacer es preceder la declaración de esa
variable con la palabra clave const. Por ejemplo, para convertir en constante una variable llamada “sensor” de tipo “byte”,
simplemente se ha de declarar así: const byte sensor; .

Existe otra manera de declarar constantes en el lenguaje Arduino, que es utilizando la directiva especial #define (heredada
del lenguaje C). No obstante, se recomienda el uso de const por su mayor flexibilidad y versatilidad.

NOTA
En los párrafos anteriores se ha comentado, en referencia a las variables numéricas, que todas ellas tienen un rango de
valores válido, y por tanto, asignar un valor fuera de este puede tener consecuencias inesperadas. Esto hay que tenerlo en
cuenta para saber elegir correctamente el tipo de variable numérica que necesitemos. En el caso de las variables enteras, lo
que uno podría pensar es utilizar siempre las de tipo “unsigned long”, las cuales admiten el rango más elevado. Pero esto no
es buena idea,porque cada variable de este tipo ocupa cuatro veces más que una variable “byte”, y si (por ejemplo) sabemos
de antemano que los valores a almacenar no serán mayores de 100, sería una completa pérdida de memoria el utilizar
variables “unsigned long”. Y la memoria del microcontrolador es uno de los recursos más preciados y escasos para irlo
desaprovechando por una mala elección de tipos.

En el supuesto caso de que un valor supere el rango válido (tanto por “encima” como por “debajo”), lo que ocurrirá es que
“dará la vuelta”, y el valor continuará por el otro extremo. Es decir, si tenemos una variable de tipo “byte” (por ejemplo) cuyo
valor es actualmente 255 y se le suma 1, su nuevo valor será entonces 0 (si se le sumara 2, valdría entonces 1, y así). Lo
mismo pasa si se supera el límite inferior: si tenemos una variable de tipo “byte” (por ejemplo) cuyo valor actual es 0 y se le
resta 1, su nuevo valor será entonces 255 (si se le restara 2, valdría entonces 254, y así). De hecho, esto lo podemos
observar si ejecutamos el sketch de ejemplo 4.1 y esperamos lo suficiente: cuando los valores de la variable “mivariable” (de
tipo “int”, recordemos) lleguen a su límite superior (32767), veremos cómo automáticamente el siguiente valor vuelve a ser el
del principio de su rango (concretamente el -32768) para seguir aumentando sin parar otra vez hasta llegar al máximo y
volver a caer de nuevo al mínimo, y así. Este fenómeno se llama “overflow”.