ARD-SYN 05 – Sintaxis (V). Tipos de datos

Facebooktwittergoogle_pluslinkedinmailFacebooktwittergoogle_pluslinkedinmail

En este artículo vamos a entrar hasta la cocina en los tipos de datos que podemos manejar con Arduino. Ya hemos mencionado, por encima, esta cuestión en un artículo anterior. Sin embargo, es necesario entrar en detalle al repecto. Antes de entrar en materia, un comentario. Arduino maneja, básicamente, tres tipos de datos:

  • Numéricos
  • Caracteres
  • Booleanos

Todo lo demás, todos los tipos de datos que podemos manejar, son variantes de alguno de estos tres.

DATOS BOOLEANOS

Son los más simples de entender y manejar. Son aquellos que representan un valor lógico que puede ser true o false. Se declaran e inicializan así:

boolean logico = false;

Cuando una variable ha sido declarada como de tipo boolean, ya sólo puede recibir uno de los dos valores mencionados. Normalmente, estas variables se usan como flags, o indicadores de si se ha hecho tal o cual operación, o se ha pasado por tal o cual parte del programa.

Cambiar su valor es muy fácil, dado que sólo hay dos posibilidades que son logicamente opuestas entre sí:

logico = !logico;

Esto hace que si la variable vale true se ponga a false, y si vale false se ponga a true.

Comprobar su valor es también muy simple:

if (logico) {
    // logico vale true
} else {
    // logico vale false
}

o, al revés, así:

if (!logico) {
    // logico vale false
} else {
    // logico vale true
}

DATOS NUMÉRICOS

Empleados para realizar todo tipo de operaciones matemáticas, llevar contadores y, en general, cualquier proceso basado en aritmética, pueden ser de distintos tipos, dependiendo del rango de valores que vayamos a necesitar. En efecto, no es lo mismo una variable donde se almacene la edad de una persona (que, normalmente, no va a pasar de 100), que una donde se almacene el saldo bancario que puede tener decimales (en mi caso es casi lo único que tiene), o un contador de pulsos, que puede llegar a cifras atronómicas.

Evidentemente, cuanto mayor sea el rango que necesitemos para una variable, más memoria se precisará para almacenarla y gestionarla, por lo que deberemos pensar para qué vamos a usar una variable, antes de declararla.

Los tipos de datos numéricos que contempla Arduino aparecen recogidos en la siguiente tabla:

TIPO DE DATO RANGO DE VALORES MEMORIA NECESARIA
byte De 0 a 255 1 byte (8 bits)
int / short De -32768 a 32767 2 bytes (16 bits)
word / unsigned int De 0 a 65535 2 bytes (16 bits)
long De -2147483648 a 2147483647 4 bytes (32 bits)
unsigned long De 0 a 4294967295 4 bytes (32 bits)
float / double De -3.4028235E+38 a 3.4028235E+38 4 bytes (32 bits)

Si nuestro sketch va a manejar dos o tres variables, el tipo de dato escogido puede ser irrelevante, cuanto más amplio, mejor. Nos curamos en salud, para que nos quepa todo. Sin embargo, si vamos a necesitar muchas variables, y memoria para un código largo es mejor ajustar los tipos de datos al contenido que pensemos que van a tener. Cómo norma general acostúmbrate a usar siempre que puedas el tipo más corto posible, sin que se produzcan desbordamientos. Por ejemplo, si piensas que una variable nunca va a tener más de 255, declárala cómo de tipo byte, pero teniendo en cuenta que si, has previsto mal y en algún momento el sketch trata de almacenar un valor por encima del límite, se va a producir un desbordamiento, con la consiguiente pérdida de datos y resultados imprevisibles.

Los datos de tipo double en realidad no existen en Arduino. Las variables para almacenamiento de números en punto flotante se declaran siempre cómo float. Usaremos este tipo siempre que pensemos que nuestra variable pueda almacenar decimales, ya que los demas tipos de datos no manejan parte fraccionaria. Así si una variable va a contener, por ejemplo, 1.2, deberá ser declarada como float, aunque nunca vaya a tener un valor superior a este.

Los distintos tipos de datos se declaran así:

  • byte miVaraibleBtye = 25; // Variable de tipo byte.
  • short miVariableShort = 350; // Variable de tipo short.
  • int miVariableInt = 7653; // Variable de tipo int.
  • word mi variableWord = 34; // Variable de tipo word.
  • unsigned int miVariableUnsignedInt = 94892; // Variable de tipo unsigned int.
  • long miVariableLong = 4993949; // Variable de tipo long.
  • unsigned long = 30404043; // Variable de tipo unsigned long.
  • float miVariableFloat = 123.98; // Variable de tipo float.

DATOS DE TEXTO

Aquí la cosa se complica un poquito más. No te asustes. Sólo es cuestión de entender cómo maneja Arduino este tipo de datos y su uso adecuado te será fácil en tus sketches.

LOS CARACTERES INDIVIDUALES

Si una variable sólo va a contener un carácter la declararemos cómo char, así:

char miCaracter = 'A';

Los caracteres en estas variables se asignan encerrándolos siempre entre comillas simples, nunca comillas dobles. Esto es algo que puede resultar un poco shocante si estás acostumbrado a trabajar con lenguajes de tipo script (PHP o JavaScript, por ejemplo), pero Arduino lo hace así. Tenlo en cuenta y todo irá bien.

También podemos declarar las variables char con el código ASCII del carácter al que representan, esta vez sin comillas. Por ejemplo, la declaración anterior podríamos haberla escrito así:

char miCaracter = 65;

Esto resulta muy práctico cuando tenemos que cambiar un carácter en base a un valor numérico cambiante. Arduino siempre nos mostrará el carácter cuando queramos ver el contenido de la variable.

Este tipo de datos consume un byte de memoria (8 bits) y puede almacenar un valor de -128 a 127. Si queremos llegar a cubrir el código ASCII completo deberemos recurrir a datos unsigned char, que declararemos así:

unsigned char miCaracter = 230;

Al igual que los datos de tipo char, también a estos se les puede asignar un carácter encerrándolo entre comillas simples, así:

unsigned char miCaracter = '&';

LAS CADENAS DE TEXTO

Arduino maneja las cadenas de texto de dos maneras diferentes. El sistema original, en las primeras versiones, implicaba (y aún implica, ya que sigue existiendo en las versiones actuales), que una cadena es, en realidad, una matriz de caracteres, es decir, de datos de tipo char. Así, podemos declarar una cadena cómo vemos aquí:

char variableCadena[8] = {'A', 'r', 'd', 'u', 'i', 'n', 'o'};

o bien así:

char variableCadena[] = "Arduino";

Observa, en el caso de la primera línea, que cada carácter individual se acota entre comillas simples, mientras que en la segunda, la cadena entera se acota entre comillas dobles.

Incluso podemos construir una matriz de cadenas, de modo que cada una de estas es, en realidad, una matriz de caracteres. Así, tendremos una matriz de caracteres bidimensional. Eso lo declaramos de la siguiente forma:

char* misCadenas[]={"Esta es la primera", "Esta es la segunda", "Esta es la tercera"};

Presta especial atención, en este tipo de declaración, al asterisco junto al tipo de variable (char*). Es la forma de decirle a Arduino que declaramos una matriz de cadenas que son realmente matrices de caracteres. Para entender cómo opera esto, vamos a ver el siguiente sketch:

Si lo ejecutas y abres tu consola serie, verás en ella lo siguiente:

Esta es la primera
Esta es la segunda
Esta es la tercera

Cómo ves, se trata cada elemento de la matriz cómo una cadena aunque, en realidad, sabemos que son datos de tipo char, porque así los hemos declarado.

Acutalmente, Arduino permite otra forma de manejar las cadenas de texto. Se trata de la implementación de la clase String. Mediante la instanciación de esta clase podemos crear objetos de cadena que tienen muchas funcionalidades para la gestión de datos de texto. Sin embargo, dado lo extenso del tema, nos vamos a reservar esto para el próximo artículo de esta serie.

     

Un comentario:

  1. Pingback: ARD-SYN 06 – Sintaxis (VI). La clase String » eldesvandejose.com

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *