Una cosa a importante a conocer son los tipos de variables de Arduino, y es por eso que en este post os hablaré de Arduino y sus tipos de variables.

Para empezar, aquí tenéis una tabla de los diferentes tipos, sus tamaños (algo muy importante a tener en cuenta), y enlaces a cada uno en la documentación oficial. Luego procederé a realizar una descripción de cada tipo para que podamos entenderlos mejor.

TipoTamañoRango
boolean1 byte0 a 1
char1 byte-128 a 127
unsigned char1 byte0 a 255
int2 bytes-32.768 a 32.767
unsigned int2 bytes0 a 65535
word2 bytes0 a 65535
long4 bytes-2.147.483.648 a 2.147483.647
unsigned long4 bytes0 a 4.294.967.295
float4 bytes3,4028235E-38 a 3,4028235E+38
double4 bytes3,4028235E-38 a 3,4028235E+38
string1 byte por letra + 1 byte de controlN/A
String()??N/A
arrayLa suma del tamaño de los elementos del array, +1 byte de controlN/A
enumN/AN/A
structN/AN/A
pointerN/AN/A
voidN/AN/A

En la tabla podéis observar que he puesto dos veces string, pero no os preocupéis, no se trata de un error. Esto se debe a que en la documentación oficial de Arduino llaman string a un array de chars, y es por eso que el tamaño de un string es el mismo que el del array en la tabla.
Además del llamado string (array de chars), existe un tipo de variable String, el cual es distinto al ya mencionado arriba. Esta se desaconseja su uso debido a que consume más memoria, pero nos podemos encontrar con casos en los que nos sea imposible evitarlo. Entre las diferencias que existen, el array es de tamaño fijo en su declaración y este no puede variar, mientras que el string si lo permite. Además disponemos de algunas funciones específicas para el tipo String que nos serían imposible de usar en un array.

Numérico

Las variables del tipo numérico sólo pueden albergar números tal y como su nombre indica, y dentro del tipo numérico se pueden encontrar dos subtipos, los cuales e son los enteros (bool, int, char…) y los decimales (float y double). Otra cosa a saber es que todas las variables indicadas en la parte superior de la tabla, son variables numéricas, y que salvo String(), array, enum, struct, pointer y void, todas pueden ser tratadas como tal.

Boolean

La variable de tipo boolean es una variable que nos permitirá guardar cero o uno en ella, por lo que sólo nos servirá para su uso en estados como por ejemplo el de un led (encendido o apagado). Teniendo en cuenta su tamaño podría ser sustituido por una variable de tipo byte o char sin problemas, lo cual nos daría mas flexibilidad.

Además, tal y como explico en mi post Ahorrar memoria SRAM en tu Arduino, la sustitución de dicho tipo por una de tipo byte junto con el uso de bits, nos permitirá tener hasta 8 booleans en el mismo byte.

Char y unsigned char

Ambos tipos disponen de la misma cantidad de números, salvo que char incluye también un rango negativo. Si queremos almacenar un número de entre 0 y 255, podremos utilizar el tipo unsigned para ello, mientras que si el número contiene dígitos negativos y va entre -128 y 127, entonces nuestra mejor opción será unsigned char.
Estos tipos también se usan para almacenar caracteres de la tabla ASCII extendida, pero char sólo nos permite almacenar letras de los primeros 128 caracteres de la tabla, mientras que si utilizamos un string (array de chars), nos permitirá almacenar cualquier carácter de la tabla.

Esta imagen muestra una tabla de caracteres ASCII extendidos.
Tabla de caracteres ASCII extendidos
void setup() {
  Serial.begin(9600);
}

void loop() {
  char test_array[] = "K";
  char test_char = 75;
  Serial.print(F("Array: "));
  Serial.println(test_array);
  Serial.print(F("Char: "));
  Serial.println(test_char);
  delay(1000);
}

En el ejemplo se puede observar cómo ambos dan el mismo resultado, pero sin embargo el array nos permite agrupar varios caracteres para formar palabras e incluso frases.

Int, unsigned int y word

Estos tipos de variables entran también en el grupo de numéricas, y por lo tanto sirven para almacenar números. A diferencia de char, este no permite almacenar letras, sino sólo números. Estos tipos de variables permiten almacenar un rango de números entre -32.768 y 32.767 para la variable de tipo int, y entre 0 y 65535 para la variable de tipo unsigned int, la cual es equivalente a una variable del tipo word.

Long y unsigned long

Estos tipos de variables serán las de mayor rango que encontraremos dentro de los distintos tipos de variables, y por lo tanto las que más ocupen. Su uso se recomienda sólo en el caso de que sea necesario almacenar un número muy grande, entre un rango de -2.147.483.648 y 2.147483.647 para signed long, y 0 a 4.294.967.295 para unsigned long.

Float y double

Con este tipo de variables entramos en las últimas del tipo numérico y las que nos permitirán el uso de números decimales. A diferencia de en C++, ambas variables son iguales (en C++ double usa el doble de memoria y también es más grande), y su rango es desde 3,4028235E-38 a 3,4028235E+38.

String

Este tipo de variable se podría decir que realmente no existe, o al menos no en este contexto, ya que es básicamente un array de tipo char. Para declararlo en nuestro programa nunca usaremos string, sino que en su lugar usaremos una definición char y unas llaves indicando que es un array.

char string[] = "Hola Mundo";

Dado que se trata de un array del tipo char, su consumo de memoria será exactamente el mismo, el cual es 1 byte de control + 1 byte por cada carácter.

String()

A diferencia del indicado anteriormente, este no se trata de un array de caracteres, sino que se trata de un String real. Dado que este tipo de variable es mutable, su consumo de memoria es muy superior. Por poner un ejemplo, un sketch básico con una variable conteniendo una frase larga consume 1.438 bytes utilizando char, mientras que la misma frase en una variable del tipo String pasa a consumir 2.690 bytes. Es por eso que se desaconseja su uso salvo que nos sea extríctamente necesario, y en el caso de que no vaya a variar se recomienda el uso de la función F, tal y como indico en mi post Ahorrar memoria SRAM en tu Arduino.

Array

Los array son grupos de variables de otros tipos, lo cual permite agrupar varias variables bajo el mismo identificador, siempre y cuando sean del mismo tipo. Esto puede ser usado para generar por ejemplo un array de chars con una frase larga en lugar de caracteres sueltos, o agrupar enteros relacionados entre sí. el tamaño de dichos arrays es igual a la suma del tamaño de todas la variables que contienen, más un byte de control.

Para acceder a una variable de dentro de un array, tendremos que hacerlo a través de su posición en dicho array (índice), y tomando como referencia el cero como primera posición. Teniendo esto en cuenta, si deseamos acceder a la tercera entrada de un array, tendremos que usar el número 2.

char array_chars[] = "Hola"; // (4 * 1) + 1 = 5 bytes
int array_ints[] = {12, 25, 46, 91}; // (4 * 2) + 1 = 9 bytes
float array_floats[5] = {12, 25, 46, 91}; // (4 * 4) + 1 = 17 bytes
Serial.prinln(array_ints[1]); // Enviará por el puerto serial 25

Void es un tipo de variable de tipo nulo, y generalmente se usa para funciones que no devuelven ningún valor.
Por otro lado tenemos las variables de tipo Enum, struct y pointer las cuales van más allá de la intención de este artículo y por lo tanto no las voy a explicar de momento.

Un saludo y espero que os haya servido.

Daniel Carrasco

DevOps con varios años de experiencia, y arquitecto cloud con experiencia en Google Cloud Platform y Amazon Web Services. En sus ratos libres experimenta con Arduino y electrónica.

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.