TIPOS DE DATOS char ---- se utilizan para almacenar caracteres, ocupan un byte. byte ---- Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255. Ej: byte unaVariable = 180; //declara 'unaVariable' como de tipo byte ****************************************************************** int --- Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales comprendidos en el rango 32,767 to -32,768. Ej: int unaVariable = 1500; // declara 'unaVariable' como // una variable de tipo entero Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como consecuencia de una operación. Por ejemplo, si x = 32767 y una posterior declaración agrega 1 a x, x = x + 1 entonces el valor se x pasará a ser -32.768. (algo así como que el valor da la vuelta). ****************************************************************** long ---- El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -2147483648 a 2147483647. Ej: long unaVariable = 90000; // declara 'unaVariable' como // de tipo long ****************************************************************** float ----- El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales. Los números de punto flotante tienen una mayor resolución que los de 32 bits con un rango comprendido 3.4028235E +38 a -3.4028235 E+38. Ej: float unaVariable = 3.14; // declara 'unaVariable' como // de tipo flotante Nota: Los números de punto flotante no son exactos, y pueden producir resultados extraños en las comparaciones. Los cálculos matemáticos de punto flotante son también mucho más lentos que los del tipo de números enteros, por lo que debe evitarse su uso si es posible. ********************************************************************** arrays ------ Un array 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 array tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser utilizado. int miArray[] = {valor0, valor1, valor2...} Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamaño y posteriormente, asignar valores a una posición especifica: int miArray[5]; // declara un array de enteros de 6 posiciones miArray[3] = 10; // asigna l valor 10 a la posición 4 Para leer de un array basta con escribir el nombre y la posición a leer: x = miArray[3]; // x ahora es igual a 10 que está en la posición 3 del array ------------------------------------------------------------------ Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que la variable de incremento del contador del bucle se utiliza como índice o puntero del array. El siguiente ejemplo usa una matriz para el parpadeo de un LED. Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la posición de índice 0 en la serie que hemos escrito dentro del array parpadeo[], en este caso 180, que se envía a la salida analógica tipo PWM configurada en el PIN10, se hace una pausa de 200 ms y a continuación se pasa al siguiente valor que asigna el índice “i”. int ledPin = 10; // LED en el PIN 10 byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array de 8 valores void setup() { pinMode(ledPin, OUTPUT); // configura la salida } void loop() { for(int i=0; i<7; i++) { analogWrite(ledPin, parpadeo[i]); delay(200); // espera 200ms } } ******************************************************************** REPITAMOS EL CONCEPTO Y COMPLETEMOS Tipos de variables Los datos que guardamos en las variables pueden ser de diferentes tipos, vamos a listar algunos de ellos. char, se utilizan para almacenar caracteres, ocupan un byte. byte, pueden almacenar un número entre 0 y 255. int, ocupan 2 bytes (16 bits), y por lo tanto almacenan número entre 2-15 y 215-1, es decir, entre -32,768 y 32,767. unsigned int, ocupa trambién 2 bytes, pero al no tener signo puede tomar valores entre 0 y 216-1, es decir entre 0 y 65,535. long, ocupa 32 bits (4 bytes), desde -2,147,483,648 a 2,147,483,647. float, son números decimales que ocupan 32 bits (4 bytes). Pueden tomar valores entre -3.4028235E+38 y +3.4028235E+38. double, también almacena números decimales, pero disponen de 8-bytes (64 bit). Siempre que elegimos un tipo de dato debemos escoger el que menos tamaño necesite y que cubra nuestras necesidades, ya que ocuparán espacio en la memoria de nuestra placa y podría darse el caso de que nuestro programa requiera más memoria de la disponible. Pero, ¿cómo “hacemos” variables en nuestro código? Es muy sencillo: indicando el tipo y el nombre de la variable. Además podemos darle o no un valor inicial. Veamos un ejemplo: Ej: char miCaracter='a'; //declaramos una variable tipo char, //llamada miCarcater y la inicializamos con valor a byte unNumero = 189; // variable tipo byte inicializada a 189 int unEntero; //variable tipo int sin inicializar unsigned int numeroPositivo = 2343; //entero positivo inicializada float numDecimal = 12.212; //numero decimal inicializado a 12,212 Hay otro tipo muy importante, String, sirve para almacenar cadenas de texto, y es fundamental a la hora de enviar texto por el puerto serie. Permite crear cadenas a partir de número, otras variables, o concatenando cadenas. Veamos algunos ejemplos String stringOne = "Hello String"; // using a constant String String stringOne = String('a'); // converting a constant char into a String String stringTwo = String("This is a string"); // converting a constant string into a String object String stringOne = String(stringTwo + " with more"); // concatenating two strings String stringOne = String(13); // using a constant integer Existe aún otro tipo importante, llamado array, que es una agrupación ordenada de datos de un tipo determinado. De momento no lo vamos a ver… vamos a ir poco a poco. Vamos a hacer un programa de ejemplo que suma dos enteros y muestra el resultado por puerto serie: int a = 5; //variable a es un entero, inicializado a 5 int b = 6; //variable b es un entero, iniciazliado a 6 int c = a + b; //variable c es un entero, inicializado a 11. void setup() { // initialize Serial Serial.begin(9600); // baudrate 9600 Serial.print("a + b equals "); Serial.println(String(c)); } void loop() { } En este programa hemos escrito todo en la función setup ya que queremos que se ejecute solo una vez. ¿Cuál de estas tres opciones crees que se imprimirá por el puerto serie? a + b equals c 5 + 6 equals 11 a + b equals 11 **************************************************************** Ámbito de las variables Vamos a explicar esto mediante ejemplos. Ámbito global int a= 5; void setup() { // initialize Serial Serial.begin(9600); // baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } Decimos que la variable a es global porque se puede acceder a ella desde cualquier parte, es decir, estamos accediendo a su valor desde las funciones setup y loop. Ámbito local Son variables que solo existen dentro del ámbito en el que han sido declaradas. Por entendernos rápidamente, un ámbito es lo que está entre llaves. Si las utilizamos fuera de su ámbito tendremos un error de compilación. Al existir solo dentro de u ámbito mi programa podría repetir el mismo nombre de variable en distintos ámbitos. Vamos a ver algunos ejemplos para explicarlo bien: void setup() { int a= 5; //la variable a solo existe dentro de la función setup // initialize Serial Serial.begin(9600); // baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { //al compilar daría un error de compilación, porque a no existe en loop a = a + 1; Serial.println(String(a)); delay(1000); } Al compilar este programa obtendremos un error de código, por la variable int a es de ámbito local, y solo existe dentro de la función setup por lo que no la podemos usar en la función loop.