Estructura de programa

setup() La funcin setup() se establece cuando se inicia un programa -sketch. Se emplea para iniciar variables, establecer el estado de los pins, inicializar libreras, etc. Esta funcin se ejecutar una nica vez despus de que se conecte la placa Arduino a la fuente de alimentacin, o cuando se pulse el botn de reinicio de la placa.

Ejemplo
int buttonPin = 3; void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); } void loop() { // ... }

loop() Luego de crear la funcin setup(), la cual inicializa y prepara los valores inciales, la funcin loop() hace justamente lo que su nombre sugiere, por lo tanto se ejecuta consecutivamente, permitindole al

programa variar y responder. sala para controlar de forma activa la placa Arduino.

Ejemplo
int buttonPin = 3; // setup inicializa la comunicacin serial y el buttonPin void setup() { beginSerial(9600); pinMode(buttonPin, INPUT); } // loop obtiene el estado del pin del botn cada vez, // y de estar presionado, lo comunica por serial. void loop() { if (digitalRead(buttonPin) == HIGH) serialWrite('H'); else serialWrite('L'); delay(1000); }

Estructuras de control

if (condicional) y ==, !=, <, > (operadores de comparacin) if, el cual puede ser usado en conjunto con uno o ms operadores de comparacin, comprueba si cierta condicin se cumple, por ejemplo, si un input posee un valor mayor a cierto nmero. El formato para una comprobacin if es el siguiente: if (algunaVariable > 50) { // hacer algo aqu. }

Este programa comprueba si la variable algunaVariable es mayor a 50. Si lo es, el programa toma una accin particular. Dicho de otra forma, si la declaracin escrita dentro de los parntesis es verdadera (true), el cdigo dentro de las llaves se ejecutar. Si no, el programa ignora dicho cdigo. Las llaves pueden ser omitidas luego de una declaracin if. De hacer esto, la siguiente lnea (definida por el punto y coma) ser la nica afectada por la condicin.

if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120){ digitalWrite(LEDpin, HIGH); } if (x > 120) { digitalWrite(LEDpin1, HIGH); digitalWrite(LEDpin2, HIGH); } // todos los ejemplos son correctos.

Las declaraciones a evaluar dentro de los parntesis, requieren el uso de uno o ms operadores: Operadores de Comparacin: x == y (x es igual a y) x != y (x no es igual a y) x < y (x es menor a y) x > y (x es mayor a y) x <= y (x es menor o igual a y) x >= y (x es mayor o igual a y)

Atencin: Ten cuidado de no usar un signo de igual solo (ej. if (x = 10) ). Un signo de igual solo es el operador que indica la asignacin de un valor, y va a asignar 10 a x. En su lugar usa el signo de igual doble (ej. if (x

== 10) ), el cual es el operador de comparacin, y comprueba si x equivale a 10 o no. El ltimo ejemplo slo da true si x equivale a 10, pero el ejemplo anterior (con un slo smbolo =) dar siempre TRUE. Esto es porque C evala la declaracin if (x=10) de la siguiente manera: 10 es asignado a x (Recuerda que un signo = solo, es el operador de asignacin), por lo tanto x ahora contiene 10. Entonces el condicional if evala 10, el cual siempre resulta TRUE, debido a que cualquier valor numrico mayor a 0 es evaluado como TRUE. Consecuentemente, if (x = 10) siempre ser evaluado como TRUE, lo cual no es el resultado deseado cuando se usa una declaracin if. Adicionalmente, la variable x ser definida en 10, lo que tampoco es una accin deseada. if tambin puede ser parte de una estructura de control de ramificacin usando la construccin if...else.

if / else if/else permite mayor control sobre el flujo del cdigo que la declaracin if bsica, por permitir agrupar mltiples comprobaciones. Por ejemplo, un input anlogo podra ser comprobado, y tomarse una accin si el valor del input es menor a 500, y, otra accin si es igual o mayor a 500. El cdigo se vera as:

if (pinCincoInput < 500) { // accin A } else { // accin B }

else puede proceder a una comprobacin if, de esta forma se pueden realizar mltiples comprobaciones en una misma estructura de condiciones. Cada comprobacin proceder a la siguiente, slo cuando su propio resultado sea FALSE. Cuando el resultado sea TRUE, su bloque de cdigo contenido, ser ejecutado, y el programa esquivar las siguientes comprobaciones hasta el final de la estructura de comprobaciones. Si ninguna comprobacin devuelve valor TRUE, el else ser ejecutado, y de no haber ninguno declarado, simplemente no sucede nada. Entonces un bloque else if puede ser usado con o sin else al final. La cantidad de declaraciones else if, y sus ramificaciones son ilimitadas.
if (pinCincoInput < 500) { // ejecutar A } else if (pinCincoInput >= 1000) { // ejecutar B } else { // ejecutar C }

Otra forma de expresar ramificaciones (branching en ingls), y realizar comprobaciones mutuamente exclusivas, es con la declaracin switch case, la cual resulta ms idnea en algunos casos.

Declaracion FOR Descripcin La declaracin for es usada para repetir un bloque encerrado entre llaves. Un incremento de un contador es usado, normalmente, para aumentar y terminar con el bucle. La estructura for es muy til para la mayora de las operaciones repetitivas, y habitualmente se usa para operaciones con vectores, para operar sobre conjuntos de datos/pines El bucle for tiene tres partes o argumentos en su inicializacin: for (initialization; condition; increment) { //funcin(es); }

La initialization, o inicializacin, se produce slo la primera vez. Cada vez que se va a repetir el bucle, se revisa la condition, o condicin: si es cierta, el bloque de funciones (y el incremento del contador) se ejecutan, y la condicin vuelve a ser comprobada de nuevo. Si la condicin es falsa, el bucle termina.

Ejemplo
// Variar la intensidad de un LED usando una salida PWM // En el pin 10 hay un LED en serie con una resistencia de // 470 ohmios int PWMpin = 10; void setup() { // no es necesario nada aqu } void loop() { for (int i=0; i <= 255; i++) { analogWrite(PWMpin, i); delay(10); } }

Consejos de programacin El bucle for, en C, es mucho ms flexible que otros bucles for en otros lenguajes, incluyendo BASIC. Cualquiera (o todos) los parmetros pueden ser omitidos, sin embargo los puntos y coma (;) son obligatorios. Tambin las inicializacin, condicin e incremento pueden

ser cualquier declaracin en C vlida, con variables independientes, y podemos usar cualquier tipo de variable, includos los float. Estos tipos de declaracin for poco usuales pueden proporcionar una solucin vlida a algunos problemas de programacin raros. Por ejemplo, usando la multiplicacin en el parmetro de incremento, podemos generar una progresin logartmica.
for(int x = 2; x < 100; x = x * 1.5) { println(x); }

Este cdigo generar: 2,3,4,6,9,13,19,28,42,63,94 Otro ejemplo es hacer apagarse/encenderse un LED poco a poco,
void loop() { int x = 1; for (int i = 0; i > -1; i = i + x) { analogWrite(PWMpin, i); if (i = 255) x = -1; // cambia de signo para apagarlo delay(10); } }

Sentencia switch / case Como las sentencias if, switch...case controla el flujo de programas permitiendo a los programadores especificar diferentes cdigos que deberan ser ejecutados en funcin de varias condiciones. En particular, una sentencia switch compara el valor de una variable con el valor especificado en las sentencias case. Cuando se encuentra una sentencia case cuyo valor coincide con dicha variable, el cdigo de esa sentencia se ejecuta. La palabra clave break sale de la sentencia switch, y es usada tpicamente al final de cada case. Si una sentencia break, la sentencia switch continuara ejecuntndo las siguientes expresiones ("fallingthrough") hasta encontrar un break, o hasta llegar al final de la sentencia switch.

Ejemplo
switch (var) { case 1: //hacer algo cuando sea igual a 1 break; case 2: //hacer algo cuando sea igual a 2 break; default: // si nada coincide, ejecuta el "default" // el "default" es opcional }

Bucles while Descripcin Los bucles while se ejecutan continuamente, hasta que la expresin dentro del parntesis, (), pasa a ser falsa. Algo debe modificar la variable comprobada, el bucle while nunca terminar. Lo que modifique la variable puede estar en el cdigo, como una variable que se incrementa, o ser una condicin externa, como el valor que da un sensor. Sintaxis
while(expresion) { // sentencia(s) }

Parmetros expresion - una sentencia C (booleana) que da un valor verdadero (true) o falso (false) Ejemplo
var = 0; while(var < 200){ // haz algo repetitivo 200 veces var++; }

do - while El bucle "'do'" trabaja de la misma manera que el bucle "'while'", con la excepcin de que la condicin se comprueba al final del bucle, por lo que este bucle se ejecuta "siempre" al menos una vez. Ejemplo:
do { delay(50); // espera a que los sensores se estabilicen x = readSensors(); // comprueba los sensores } while (x < 100); //si se cumple, se repite el bucle

break break es usado para salir de los bucles do, for, o while, pasando por alto la condicin normal del bucle. Es usado tambin para salir de una estructura de control switch. Ejemplo
for (x = 0; x < 255; x ++) { digitalWrite(PWMpin, x); sens = analogRead(sensorPin); if (sens > threshold){ // bail out on sensor detect x = 0; break; // sale del bucle for. } delay(50); }

continue La sentencia continue omite el resto de iteraciones de un bucle (do, for, o while). Contina saltando a la condicin de bucle y procediendo con la siguiente iteracin. Ejemplo
for (x = 0; x < 255; x ++) { if (x > 40 && x < 120){ continue; } digitalWrite(PWMpin, x); delay(50); }

// crea salto en estos valores

return Termina una funcin y devuelve un valor a la funcin que la llama. Puede no devolver nada. Sintaxis
return; return valor; // ambas formas son correctas

Parmetros valor: cualquier variable o tipo constante

Ejemplos Una funcin que compara la entrada de un sensor a un umbral

int comprobarSensor() { if (analogRead(0) > 400) { return 1; else{ return 0; } }

La palabra clave return es til para depurar una seccin de cdigo sin tener que comentar una gran cantidad de lneas de cdigo posiblemente incorrecto.
void loop() { // cdigo magnfico a comprobar aqu return; // el resto del programa del que se desconfa // que nunca ser ejecutado por estar detrs de return }

goto Cambia el flujo de programa, saltando la ejecucin al punto etiquetado que se le indique.

Sintaxis label: goto label; // enva el flujo de programa a la lnea de label Consejo Usar goto no est aconsejado en la programacin en C, y algunos autores de libros sobre este lenguaje indican que esta declaracin nunca es necesaria. Sin embargo, si se usa de forma razonada, puede simplificar ciertos programas. La razn que muchos programadores emplean contra el uso del goto es que con su uso indiscriminado es fcil crear programas sin un flujo definido, por lo que se dificulta mucho la depuracin. Como dicen, hay instancias donde la declaracin goto puede ser til, simplificando el cdigo. Una de estas situaciones es romper varios bucles for anidados, o bloques lgicos if, en ciertas condiciones. Ejemplo
for (byte r = 0; r < 255; r++) { for (byte g = 255; g > -1; g--) { for (byte b = 0; b < 255; b++) { if (analogRead(0) > 250) { goto bailout;} // ms instrucciones ... } } } bailout:

mas sintaxis ; punto y coma Utilizado para terminar una declaracin.

Ejemplo
int a = 13;

Truco Olvidarse de terminar una lnea con el punto y coma har que se lance un error de compilacin. El texto del error puede ser obvio y referirse concretamente a la ausencia del punto y coma, pero puede no hacerlo. Si aparece un error de compilacin impenetrable y aparentemente incoherente, una de las primeras cosas a hacer es comprobar que no falta ningn punto y coma cerca de la lnea en la que el compilador da el error.

{} Llaves Las Llaves son una parte importante del lenguaje C. Se utilizan en diferentes construcciones (ver ejemplos al final), esto a veces puede ser confuso para los principiantes. Una llave de apertura "{" siempre debe ir seguida de una llave de cierre "}". Esta es una condicin a la que se suele referir como llaves emparejadas. El IDE de Arduino incluye una caracterstica para

comprobar si las llaves estn emparejadas. Slo tienes que seleccionar una Llave o incluso hacer click en el punto de insercin que sigue inmediatamente a una llave, y su compaera lgica ser seleccionada. Los programadores principiantes y los programadores que llegan a C desde el lenguaje BASIC a menudo encuentran dificultades o grandes confusiones usando llaves. Despus de todo, las llaves reemplazan el RETURN en una subrutina(funcin), el ENDIF en un condicional y el NEXT en un loop FOR. Dado que el uso de las llaves es tan variado, es una buena prctica de programacin escribir la llave de cierre inmediatamente despus de escribir la llave de apertura, cuando se inserta una construccin que requiere llaves. Despus insertar algunos saltos de lnea (lneas en blanco) entre las llaves y comenzar a insertar sentencias. De esta forma tus llaves y su posicin, nunca llegarn a estar desemparejadas. Llaves desemparejadas a menudo pueden conducir a errores de compilacin misteriosos y difciles de comprender, que pueden ser complicados de rastrear en un programa largo. Debido a sus variados usos, las llaves tambin son increblemente importantes para la sintaxis de un programa, el movimiento de una llave una o dos lneas, a menudo afecta de manera dramtica el significado de un programa.

Usos principales de las Llaves Funciones

void myfunction(tipodato argumento) { sentencia(s) }

Loops
while (expresin booleana) { sentencia(s) } do { sentencia(s) } while (expresin booleana); for (inicializacin; condicin final; expresin incremento) { sentencia(s) }

Sentencias Condicionales
if (expresin booleana) { sentencia(s) } else if (expresin booleana) { sentencia(s) } else { sentencia(s) }

Comentarios Los comentarios son lneas en el programa para aclarar el funcionamiento del programa. Estas lneas son ignoradas por el compilador y no se exportan al procesador. No ocupan espacio. El nico propsito de los comentarios es que entiendas (o recuerdes) cual es el funcionamiento de tu programa. Existen dos maneras distintas de marcar una lnea como comentario: Ejemplo
x = 5; // Esto es una lnea simple de comentario. Todo lo //que va despus de la doble barra es un comentario // Hasta el final de la lnea

/* Esto es un comentario multilnea - salo para comentar bloques enteros de cdigo if (gwb == 0){ // Una lne de comentario sencilla puede //usarse dentro de un comentario multilnea /* pero no otro comentario multilnea- esto

x = 3; no es vlido */ } // No olvides cerrar el comentario multilnea */

Consejo Cuando ests experimentando con cdigo, "comentar" partes del programa es una til de eliminar lneas que puedan contener errores. As dejamos las lneas en el cdigo, pero como comentario, as que sern ignoradas por el compilador. Es especialmente til cuando estamos intentando localizar el problema, o cuando el compilador rechaza el programa.

Define #define un componente de C muy til que permite al programador dar un nombre a un valor constante antes de que se compile el programa. Las constantes definidas en arduino no aumentan el tamao que el programa ocupa en el chip. El compilador remplaza las referencias a estas constantes con el valor definido en tiempo de compilacin. Aunque esto puede tener efectos indeseados, si por ejemplo, un nombre de constante que ha sido #defined se incluye en otra constante o nombre de variable. En este caso el texto ser reemplazado por el nmero (o texto) #defined. En general, la palabra clave const es preferible al definir constantes y es la que debemos de usar en vez de #define. El define de Arduino tiene la misma sintaxis que el define de C: Sintaxis
#define nombredeConstante valor

Observa que # es necesario.

Ejemplo
#define ledPin 3 // El compilador reemplazara cualquier mencin a ledPin con el //valor 3 en tiempo de compilacin.

Consejo No poner punto y coma despus de la sentencia #define. Si lo haces, Se mostrarn errores crpticos de compilacin.
#define ledPin 3; // esto es un error

De la misma manera, incluir un signo de igualdad despus de la sentencia #define tambin mostrar errores crpticos de compilacin.
#define ledPin = 3 // esto tambin es un error

#include #include es utilizado para inclur libreras externas en tu sketch. Esto otorga al programador acceso a una gran cantidad de libreras C estndar (grupos de funciones ya hechas), y tambin libreras escritas especialmente para Arduino. Nota que #include, similar a #define, no posee punto y coma de terminacin, y el compilador producir mensajes de error si se agrega.

Ejemplo En este ejemplo, se incluye una librera que se utiliza para poner los datos en el espacio flash del programa en lugar de la RAM. Esto ahorra espacio de memoria RAM y hace ms prcticas las grandes tablas de operaciones de bsqueda.

#include <avr/pgmspace.h> prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702 25764, 8456, 0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500}; , 9128, 0,

Operaciones aritmticas = operador de asignacin (un solo smbolo de "igual") Guarda el valor en la derecha del smbolo "=" dentro de la variable a la izquierda del smbolo "=". El signo de igualdad "=" en el lenguaje de programacin C se llama el operador de asignacin. Tiene un significado diferente que en la clase de lgebra en el que se indica una ecuacin o igualdad. El operador de asignacin le dice al microcontrolador que evale cualquier valor o expresin en el lado derecho del signo igual, y lo almacene en la variable a la izquierda del signo igual.

Ejemplo
int sensVal; // declara una variable int llamada sensVal senVal = analogRead(0); // guarda el valor (digitalizado) del //voltaje de entrada del pin analgico 0 en SensVal

Sugerencias de programacin La variable en el lado izquierdo del operador de asignacin (signo "=") tiene que ser capaz de mantener el valor almacenado en ella. Si no es suficientemente grande para contenerlo, el valor almacenado en la variable ser incorrecto.

No confunda el operador de asignacin [ = ] (un solo signo igual) con el operador de comparacin [ == ] (un signo igual doble), que evala si dos expresiones son iguales.

Suma, Resta, Multiplicacin y Divisin Descripcin Estos operadores devuelven la suma, diferencia, producto o cociente de los dos operandos. La operacin se lleva a cabo utilizando el tipo de datos de los operandos, por lo que, por ejemplo, 9 / 4 resulta 2 desde 9 y 4 que son enteros int. Esto tambin significa que la operacin puede desbordarse si el resultado es mayor que el que se puede almacenar en el tipo de datos (por ejemplo, la suma de 1 a un int con el valor de 32.767 resulta -32.768). Si los operandos son de tipos diferentes, se utiliza el tipo del "ms grande" para el clculo. Si uno de los nmeros (operandos) es del tipo float o del tipo double, se usar coma flotante para el clculo. Ejemplos
y x i r = = = = y x j r + * / 3; 7; 6; 5;

Sintaxis
result result result result = = = = value1 value1 value1 value1 + * / value2; value2; value2; value2;

Parmetros: value1: cualquier variable o constante value2: cualquier variable o constante Sugerencias de programacin:

Debes saber que las integer constants por defecto son int, as que algunos clculos con constantes pueden provocar

desbordamiento (p.e. 60 * 1000 devolver un resultado negativo)

Elige los tamaos de variable que sean suficientemente grandes como para alojar el resultado de tus calculos.

Debes saber en qu punto tu variable se desbordar en su mximo, y que esto tambin ocurre en su mnimo. p.e. (0 - 1) o tambin (0 - - 32768)

Para clculos matemticos que requieren fracciones, usa variables float, pero ten en cuenta los inconvenientes: gran tamao, velocidades bajas de clculo

Usa

el operador de conversin (casting).

Por ejemplo:

(int)myFloat para convertir el tipo de una variable en el momento.

% (mdulo) Descricin Calcula el resto de la divisin entre dos enteros. Es til para mantener una variable dentro de un rango particular (por ejemplo el tamao de un array) Sintaxis resultado = dividendo % divisor Parametros dividendo: el nmero que se va a dividir divisor: el nmero por el que se va a dividir Devuelve el resto de la divisin Ejemplo
x x x x = = = = 7 9 5 4 % % % % 5; 5; 5; 5; // // // // x x x x ahora ahora ahora ahora contiene contiene contiene contiene 2 4 0 4

Cdigo de ejemplo
/* actualiza un valor en el array cada vez que se pasa por el bucle */ int valores[10]; int i = 0; void setup() {}

void loop() { valores[i] = analogRead(0); i = (i + 1) % 10; // el operador mdulo prevalece sobre la // variable }

Nota El operador modulo no funciona con datos en coma flotante (float)

Operadores de comparacin if (condicional) y ==, !=, <, > (operadores de comparacin) if, el cual puede ser usado en conjunto con uno o ms operadores de comparacin, comprueba si cierta condicin se cumple, por ejemplo, si un input posee un valor mayor a cierto nmero. El formato para una comprobacin if es el siguiente:
if (algunaVariable > 50) { // hacer algo aqu. }

Este programa comprueba si la variable algunaVariable es mayor a 50. Si lo es, el programa toma una accin particular. Dicho de otra forma, si la declaracin escrita dentro de los parntesis es verdadera (true), el cdigo dentro de las llaves se ejecutar. Si no, el programa ignora dicho cdigo. Las llaves pueden ser omitidas luego de una declaracin if. De hacer esto, la siguiente lnea (definida por el punto y coma) ser la nica afectada por la condicin.

if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120){ digitalWrite(LEDpin, HIGH); } if (x > 120){ digitalWrite(LEDpin1, HIGH); digitalWrite(LEDpin2, HIGH); } // todos los ejemplos son correctos.

Las declaraciones a evaluar dentro de los parntesis, requieren el uso de uno o ms operadores: Operadores de Comparacin:
x x x x x x == != < > <= >= y y y y y y (x (x (x (x (x (x es no es es es es igual a y) es igual a y) menor a y) mayor a y) menor o igual a y) mayor o igual a y)

Atencin: Ten cuidado de no usar un signo de igual solo (ej. if (x = 10) ). Un signo de igual solo es el operador que indica la asignacin de un valor, y va a asignar 10 a x. En su lugar usa el signo de igual doble (ej. if (x == 10) ), el cual es el operador de comparacin, y comprueba si x equivale a 10 o no. El ltimo ejemplo slo da true si x equivale a 10, pero el ejemplo anterior (con un slo smbolo =) dar siempre TRUE. Esto es porque C evala la declaracin if (x=10) de la siguiente manera: 10 es asignado a x (Recuerda que un signo = solo, es el

operador de asignacin), por lo tanto x ahora contiene 10. Entonces el condicional if evala 10, el cual siempre resulta TRUE, debido a que cualquier valor numrico mayor a 0 es evaluado como TRUE. Consecuentemente, if (x = 10) siempre ser evaluado como TRUE, lo cual no es el resultado deseado cuando se usa una declaracin if. Adicionalmente, la variable x ser definida en 10, lo que tampoco es una accin deseada. if tambin puede ser parte de una estructura de control de ramificacin usando la construccin if...else.

operadores boleanos Se pueden usar dentro de operaciones condicionales o en una sentencia if. && (AND lgico) Verdadero slo si ambos operadores son Verdadero, por ejemplo:
if (digitalRead(2) == HIGH { // lee dos pulsadores // ... } && digitalRead(3) == HIGH)

Es Verdadero slo si ambas entradas ests activadas, es decir, en estado HIGH.

|| (OR lgico) Verdadero si alguno de los dos operadores es Verdadero, por ejemplo:
if (x > 0 || y > 0) { // ... }

Es Verdadero si alguno de los valores x y es mayor que 0. ! (NOT) Verdadero si el operador es Falso, por ejempo:
if (!x) { // ... }

Es Verdadero si el valor de x es Falso (p. e. si x es igual a 0).

Atencin. Asegrate de no confundir el operador AND booleano && (doble signo &) con el operador AND para bits & (un solo signo &). De la misma manera no hay que confundir el operador OR booleano || (doble barra vertical) con el operador OR para bits | (una sola barra vertical). El operador NOT de bits ~ (tilde) tiene una apariencia muy diferente del operador NOT booleano ! (exclamacin o "bang", como lo llaman algunos programadores), pero debes asegurarte de usar cada uno de ellos dentro del contexto adecuado.

Ejemplos.
if (a >= 10 && a <= 20){} // Verdadero slo si el valor de // a est entre 10 y 20

operadores de acceso a punteros El operador puntero & (referencia) and * (dereferencia) Los punteros son uno de los temas mas complicados para aquellos que se inician en el lenguaje C, y es posible escribir la mayora de los programas para Arduino sin usar punteros. Sin embargo para manipular ciertos tipos de estructuras de datos, el uso de punteros puede simplificar el cdigo. El conocer como usar punteros es algo que puede ser muy til en muchos casos.

Operaciones a nivel de bits Operadores bit a bit: AND (&), OR (|) y XOR (^) Los operadores bit a bit realizan sus clculos a nivel de los bits de las variables. Ayudan a resolver muchos de los problemas ms comunes a nivel de programacin. La mayora del material que sigue est sacado de un excelente tutorial de matemtica lgica.

Descripcin y sintaxis A continuacin se muestras las descripciones y la sintaxis de estos operadores lgicos. Operador bit a bit AND (&) Este operador, en C++, es un ampersand (&) simple, usado entre dos expresiones enteras. Opera en cada posicin de bit en ambas expresiones de forma independiente, de acuerdo a esta regla: si ambas posiciones de entrada son un 1, el resultado devuelto es un 1; en otro caso, ser un 0. Por ejemplo:
0 0 1 1 0 1 0 1 ---------0 0 0 1 operando1 operando2 (operando1 & operando2) - resultado devuelto

En Arduino, el tipo entero (int) ocupa 16bits, pero usando & entre dos expresiones tipo int, causa 16 operaciones AND simultneas. En el siguiente cdigo:
int a = 92; int b = 101; int c = a & b; // en binario: 0000000001011100 // en binario: 0000000001100101 // resultado: 0000000001000100, 68 en dec.

Cada uno de los 16bits de las palabras a y b son procesados usando el operador bit a bit AND y se guarda el resultado en la palabra c. Uno de los usos ms comunes de este operador es seleccionar un determinado (o determinados) bits dentro de un valor entero, tambin llamado enmascaramiento (masking). Ms abajo se incluye un ejemplo.

Operador bit a bit OR (|) Este operador, en C++, se simboliza como una barra vertical, |. Como el operador AND, este operador trabaja de forma independiente cada pareja de bits. Sin embargo, lo que hace (lgicamente) es diferente: el operador OR devuelve un 1, si alguno (o los dos bits) es un 1; mientras que slo devuelve un 0 si ambos bits lo son. En otras palabras:
0 0 1 1 0 1 0 1 ---------0 1 1 1 operando1 operando2 (operando1 | operando2) - valor devuelto

A continuacin un ejemplo de uso de este operador:

int a = 92; int b = 101; int c = a | b; // en binario: 0000000001011100 // en binario: 0000000001100101 // resultado: 0000000001111101, 125 en dec.

Programa de ejemplo Un trabajo comn de los operadores vistos hasta ahora es leermodificar-escribir en un puerto. En los microcontroladores, un puerto es un nmero de 8bits que representa la condicin (estado) de cada pin. Escribir en un puerto controla todos los pines de ese puerto a la vez. PORTD es una constante definida para referirse a los estados de salida de los pines digitales 0, 1, 2, 3, 4, 5, 6 y 7. Si hay un 1 en una determinada posicin, ese pin se encuentra a nivel alto (HIGH). (Los pines necesitan estar declarados como salida usando la instruccin pinMode). Entonces, si escribimos PORTD = B00010100;, pondremos

los pines 2 y 4 a nivel alto. Un ligero problema es que, al asignarle un valor al puerto directamente, se puede modificar el valor de otro pin, por ejemplo, el valor del bit 0 y 1 del puerto D, usados por el Arduino en comunicaciones serie, por lo que podramos estar interfiriendo en esa comunicacin. Explicado esto, el algoritmo del programa de ejemplo es:

Leer el valor actual del puerto y borrar slo los bits correspondientes con los (operador AND). pines que queremos controlar

Combinar el valor modificado del puerto con el valor real del puerto, para que se reflejen los cambios en los bits que controlamos (operador OR).

int i; int j;

// variable de contador

void setup() { DDRD = DDRD | B11111100; // configura los bits (pines) a 1 como //salida, sin tocar el 0 y el 1 // es igual que hacer pinMode(pin, OUTPUT), // pero de una sola vez. Serial.begin(9600); } void loop() { for (i=0; i<64; i++) { PORTD = PORTD & B00000011; // borra los bits, excepto los 0 y 1. j = (i << 2); // desplaza dos posiciones la variable, // introduciendo 0 por la derecha, para // no interferir con el valor de // esos pines PORTD = PORTD | j; // combina la informacin del puerto // con la nueva para los pines del LED Serial.println(PORTD, BIN);// sirve para comprobar la mscara delay(100); } }

Operador bit a bit XOR (^) Este es un operador poco usado en C++, llamado or-exlcusiva (X-OR). Este operador es escrito usando el caracter ^. Es similar al operador or (|), pero slo devuelve un 1 cuando los bits son diferentes; devolviendo 0 en el resto de los casos. Por ejemplo:
0 0 1 1 0 1 0 1 ---------0 1 1 0 operando1 operando2 (operando1 ^ operando2) - valor devuelto

A continuacin un pequeo cdigo de ejemplo:

int x = 12; int y = 10; int z = x ^ y; // binario: 1100 // binario: 1010 // binario: 0110, 6 en decimal

Este operador se suele usar para invertir (cambiar 0 a 1, o viceversa, tambin llamado toggle), algunos (o todos) bits de una expresin. Siempre que una posicin de la mscara est a 1, esa posicin ser invertida en la palabra de entrada. Si hay un 0 en la mscara, esa posicin no se ver afectada. A continuacin un ejemplo para hacer parpadear un LED en la salida digital 5.
// Blink_Pin_5. Ejemplo de OR exclusiva void setup() { DDRD = DDRD | B00100000; // pin 5 configurado como salida, // pinMode(5, OUTPUT); Serial.begin(9600); } void loop() { PORTD = PORTD ^ B00100000; delay(100); }

// invierte el bit 5 (pin digital 5) // y no modifica el resto

Operador NOT (~) a nivel de bits El operador bit a bit NOT, en C++, es el caracter ~. A diferencia de los operadores AND (&) y OR (|), el operador NOT es aplicado nicamente a un operando. Este operador lo que hace es cambiar cada bit de la palabra por su contrario: los 0 pasan a ser 1, y viceversa. Por ejemplo:
0 1 operando1 ---------1 0 ~ operando1

int a = 103; int b = ~a;

// en binario: // en binario:

0000000001100111 1111111110011000 = -104

Posiblemente te sorprendas de ver que el resultado da un valor negativo. Esto es debido a que el bit ms significativo (msb) es llamado, tambin, bit de signo. Si este bit es un 0, el valor del nmero ser interpretado como positivo, mientras que si es 1, se interpretar como un negativo. Esta codificacin para los nmeros positivos y negativos se denomina "'Complemento a 2'" (Ca2). Como anotacin, es interesante saber que para cualquier entero X, ~X es lo mismo que X-1 A veces, el bit de signo en un entero con signo (signed int) puede causar algunos problemas imprevistos.

Desplazador de bits a la izquierda (<<), desplazador de bits a la derecha (>>) Descripcin Hay dos operadores de desplazamiento en C++: el operador de desplazamiento izquierdo << y el operador de desplazamiento derecho >>. Estos operadores hacen que los bits del operando izquierdo sean desplazados a la izquierda o a la derecha el nmero de posiciones especificadas por el operando derecho.

Sintaxis variable << numero_de_bits variable >> numero_de_bits

Parmetros variable - (byte, int, long) numero_de_bits integer <= 32 Ejemplo:

int a = 5; int b = a << 3; int c = b >> 3; // binario: 0000000000000101 // binario: 0000000000101000, o 40 en dec // binario: 0000000000000101, o vuelta al 5

Cuando desplazas un valor x, y bits (x << y), los bits ms a la izquierda de x se pierden, literalmente desplazados de la existencia:
int a = 5; int b = a << 14; // bin: 0000000000000101 // bin: 0100000000000000, el primer 1 se descarta

Una manera facil de entender como funciona el operador de desplazamiento a la izquierda es pensar que funciona multiplicando el operando izquierdo por dos elevado al valor del operando derecho. Por ejemplo, se pueden usar las siquientes expresiones para generar potencias de 2:
1 << 0 1 << 1 1 << 2 1 << 3 ... 1 << 8 1 << 9 1 << 10 ... == == == == 1 2 4 8

== 256 == 512 == 1024

Cuando desplazas x a la derecha, y bits(x >> y), y el bit mas alto o mas significativo de x es un 1, el comportamiento depende del tipo exacto de dato que es x. Si x es un entero (int), el bit mas significativo es el bit de signo, que determina si x es negativo o no, como hemos discutido anteriormente. En este caso, el bit de signo esta copiado en los bits ms bajos, por razones histricamente esotricas:
int x = -16; int y = x >> 3; // binary: 1111111111110000 // binary: 1111111111111110

Este comportamiento,llamado extensin de signo, no siempre es el comportamiento que quieres. En su lugar, tu querras que introdujera ceros desde la izquierda. Resulta que las normas de desplazamiento a la derecha son diferentes para las expresiones enteras sin signo, por lo que puedes usar un cambio de tipo de variable para impedir que los unos se copien desde la izquierda:
int x = -16; int y = (unsigned int)x >> 3; // binario: 1111111111110000 // binario: 0001111111111110

Si tienes cuidado de evitar la extensin de signo, puedes usar el operador de desplazamiento a la derecha >> como una manera de dividir por potencias de 2. Por ejemplo:
int x = 1000; int y = x >> 3; // divisin entera de 1000 entre 8, y = 125.

Operadores compuestos ++ (incremento) / -- (disminucin) Descripcin Incrementa o disminuye una variable

Sintaxis
x++; ++x; x-- ; --x ; // incrementa x en uno y regresa el valor anterior de x // incrementa x en uno y regresa el nuevo valor de x // disminuye x en uno y regresa el valor anterior de x // disminuye x en uno y regresa el nuevo valor de x

Parmetros x: un entero o long (puede aceptar sin signo)

Devuelve El valor original o el resultante del incremento o disminucin de la variable.

Ejemplos
x = 2; y = ++x; y = x--; // x ahora guarda 3, y guarda 3 // x guarda 2 de nuevo, y sigue guardando 3

+= , -= , *= , /= Descripcin Realiza una operacin matemtica de una variable con respecto a otra variable o una constante. El operador += (y los dems operadores) son una forma simplificada de la sintaxis completa, tal y como se muestra ms abajo. Sintaxis
x x x x += -= *= /= y; y; y; y; // // // // equivalente equivalente equivalente equivalente a a a a la la la la expresin expresin expresin expresin x x x x = = = = x x x x + * / y; y; y; y;

Parmetros x: cualquier tipo de variable y: cualquier tipo de variable o constante Ejemplos

x x x x x = 2; += 4; -= 3; *= 10; /= 2; // // // // x x x x ahora ahora ahora ahora es es es es 6 3 30 15

Operador compuesto OR (|=0) Descripcin Este operador compuesto se usa, normalmente, para asignar el valor alto (HIGH, 1) a un bit (o varios) dentro de una variable. Sintaxis:
x |= y; // equivale a x = x | y;

Parmetros x: una variable tipo char, int o long. y: una constante o variable tipo char, int o long. Ejemplo:
myByte = B10101010; myByte |= B00000011; //Ahora myByte vale B10101011

Variables Constantes Las constantes variables que vienen predefinidas en el lenguaje de Arduino. Se usan para facilitar la lectura de los programas. Clasificamos las constantes en grupos. Las que definen niveles lgicos, verdadero (true) y falso (false) (Constantes Booleanas)

Existen dos constantes para representar si algo es cierto o falso en Arduino: true, y false. false false es el ms sencillo de definir. false se define como 0 (cero). true true se define la mayora de las veces como 1, lo cual es cierto, pero tiene una definicin ms amplia. Cualquier entero que es no-cero es TRUE, en un sentido Booleano. As, en un sentido Booleano, -1, 2 y 200 son todos true. Ten en cuenta que las constantes true y false se escriben en minsculas, al contrario que HIGH, LOW, INPUT, y OUTPUT.

Las que definen el nivel de los pines, nivel alto (HIGH) y nivel bajo (LOW) Cuando leemos o escribimos en un pin digital, existen slo dos valores que podemos obtener o asignar: HIGH y LOW.

HIGH El significado de HIGH (en referencia a un pin) depende de si el pin est configurado como entrada (INPUT) o como salida (OUTPUT). Cuando un pin se configura como entrada (INPUT) usando pinMode, y

se lee con digitalRead, el microcontrolador nos retornar HIGH si en el pin hay 3 voltios o ms. Un pin puede ser configurado como entrada (INPUT) usando pinMode, y despus establecerlo a HIGH con digitalWrite, esto conectar el pin a 5 Voltios a travs de una resistencia interna de 20K, resistencia pullup , la cual establecer el pin al estado de lectura HIGH a menos que la conectemos a una seal LOW a travs de un circuito externo. Cuando un pin se configura como salida (OUTPUT) con pinMode, y se establece a HIGH con digitalWrite, el pin tiene 5V.

LOW El significado de LOW difiere tambin segn est configurado como entrada (INPUT) o como salida (OUTPUT). Cuando un pin est configurado como entrada (INPUT) con pinMode, y se lee con digitalRead, el microcontrolador retornar LOW si el voltaje presente en el pin es de 2V o menor. Cuando un pin es configurado como salida (OUTPUT) con pinMode,y establecido LOW con digitalWrite, el pin tiene 0 voltios. Las que definen los pines digitales, INPUT y OUTPUT Los pines digitales pueden ser usados como entrada (INPUT) o como salida (OUTPUT). Cambiando un pin de INPUT a OUTPUT con pinMode() el comportamiento elctrico del pin cambia drsticamente.

Pines configurados como entradas Los pines de Arduino (Atmega) configurados como INPUT con pinMode() se dice que se encuentran en un estado de alta impedancia. Una forma de explicar esto es que un pin configurado como entrada se le aplica una muy baja demanda, es decir una resistencia en serie de 100 Megohms. Esto lo hace muy til para leer un sensor, pero no para alimentar un LED. Pines configurados como salidas Los pines configurados como salida (OUTPUT) con pinMode() se dice que estan en estado de baja impedancia. Esto implica que pueden proporcionar una sustancial cantidad de corriente a otros circuitos. Los pines de Atmega pueden alimentar (proveer de corriente positiva) o meter (proveer de masa) hasta 40 mA (miliamperios) de corriente a otros dispositivos/circuitos. Esto o hace muy til para alimentar LED's pero inservible para leer sensores. Los pines configurados como salida pueden deteriorarse o romperse si ocurre un cortocircuito hacia los 5V o 0V . La cantidad de corriente que puede proveer un pin del Atmega no es suficiente para la mayora de los rels o motores, y es necesario aadir circuitera extra.

Integer Constants Integer Constants son nmeros utilizados directamente en un sketch, como 123. Por defecto, stos nmeros son tratados como int, pero puedes cambiarlo con las letras U y L (ver abajo). Normalmente, las constantes integer son tratadas como enteros base 10 (decimales), pero se puede utilizar notacin especial (formateadores) para ingresar nmeros en otras bases. Base 10 (decimal) 2 (binario) Ejemplo 123 B1111011 Formateador Ninguno. Antecede "B" Comentario Slo funciona con valores de 8 bits (0 to 255). Caracteres 0-1 vlidos. Caracteres 0-7 vlidos. Caracteres 0-9, A-F, a-f vlidos.

8 (octal) 16 (hexadecimal)

0173 0x7B

Antecede "0" Antecede "0x"

Decimal es base 10. Esta es la matemtica de sentido comn con que se conocen. Para constantes sin otros prefijos, se asume el formato decimal. Ejemplo:
101 // igual a 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Binary es base dos. Slo caracteres 0 y 1 son vlidos. Ejemplo:

B101 // igual a 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)

El formateador binario slo funciona en bytes (8 bits) entre 0 (B0) y 255 (B11111111). Si resulta conveniente ingresar un entero (int, 16 bits) de forma binaria, puedes hacer un procedimiento de dos pasos, como a continuacin:

valorInt = (B11001100 * 256) + B10101010;

// B11001100 es el // ''byte'' alto.

Octal es base ocho. Slo caracteres de 0 hasta 7 son vlidos. Los valores Octales son indicados por el prefijo "0" Ejemplo:
0101 // igual a 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Atencin Es posible generar un bug o error difcil de encontrar al inclur (de forma involuntaria) un cero antecediento una constante, logrando as que el compilador interprete tu constante como octal.

Hexadecimal ( hex) es base diecisis. Los caracteres vlidos son del 0 al 9, y las letras desde la A hasta la F; A tiene el valor de 10, B es 11, C es 12, D es 13, E es 14, y la F, como ya habrs adivinado, es 15. Los valores hexadecimales se indican con el prefijo "0x". Nota que los valores de la A a la F, pueden ser escritos en mayscula o minscula. Ejemplo:
0x101 // igual a 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

Formateadors U & L Por defecto, una constante en enteros es tratada como int con las limitaciones concomitantes en los valores. Para especificar una constante en enteros con otro tipo de datos, continala con:

una 'u' 'U' para forzar la constante a un formato de datos unsigned. Ejemplo: 33u

una 'l' 'L' para forzar la constante a un formato de datos long. Ejemplo: 100000L

un 'ul' 'UL' para forzar la constante a un formato de datos unsigned long. Ejemplo: 32767ul

Constantes en coma flotante De manera similar a las constantes enteras (integer), las constantes en coma flotante se utilizan para hacer el cdigo ms legible. Las constantes en coma flotante se intercambian en el momento de la compilacin por su valor. Ejemplos
n = .005;

Las constantes en coma flotante pueden ser expresadas en una variedad de notaciones cientficas. 'E' y 'e' estn ambas aceptadas como indicadores de exponente vlidos.

constante coma flotante 10.0 2.34E5 67e-12

se evala como: 10 2.34 * 10^5 67.0 * 10^-12

tambin se evala como:

234000 .000000000067

Tipos de datos void La palabra reservada void se usa slo en la declaracin de funciones. Indica que se espera que no devuleva informacin a la funcin donde fu llamada. Ejemplo:

// varias acciones se llevan a cabo en las funciones "setup" y "loop" // pero no se reporta ninguna informacin al programa principal. void setup() { // ... } void loop() { // ... }

booleanos Un booleano slo puede tomar dos valores, Verdadero o Falso. Cada booleano ocupa un nico byte en la memoria. Ejemplo:
int LEDpin = 5; int switchPin = 13; // LED en el pin 5 // pulsador en pin 13, su otro pin a GND // crea la variable booleana running y // le asisga el valor Falso (false)

boolean running = false;

void setup() { pinMode(LEDpin, OUTPUT); pinMode(switchPin, INPUT); digitalWrite(switchPin, HIGH); }

// conecta la resistencia pull-up // interna del pin 13

void loop() { if (digitalRead(switchPin) == LOW) { // si el pulsador es accionado la pull-up // mantiene el pin en estado HIGH delay(100); // retardo para impedir rebote en pulsador running = !running; // invierte el valor de variable running digitalWrite(LEDpin, running) // enciende el LED } }

char

Descripcin Es un tipo de dato que ocupa un byte de memoria y almacena un valor de carcter. Los carcteres literales se escriben con comillas simples: 'A' (para varios carcteres -strings- utiliza dobles comillas "ABC"). De todas maneras los carcteres son almacenados como nmeros. Puedes ver su codificado en la tabla ASCII. Con esto podemos entender que es posible realizar clculos aritmticos con los carcteres, en este caso se utiliza el valor ASCII del carcter (por ejemplo 'A' + 1 tiene el valor de 66, ya que el valor ASCII de la letra mayscula A es 65). Mira Serial.println para tener mas informacin de como son traducidos a nmeros los carcteres. El tipo de datos char tiene signo. esto significa que codifica nmeros desde -128 hasta 127. Para un dato de un byte (8bits), utiliza el tipo de dato "byte".

Ejemplo
char miChar = 'A'; char miChar = 65;

// los dos son equivalentes

unsigned char Descripcin Un tipo de datos caracter sin firmar (unsigned char) ocupa 1 byte de memoria. Del tipo de datos que byte. El tipo de datos unsigned char codifica nmeros de 0 a 255. Para mantener la consistencia en el estilo de programacin de Arduino, se prefiere el tipo de datos byte.

Ejemplo
unsigned char miChar = 240;

byte Descripcin Un byte almacena un nmero sin signo de 8-bit, desde 0 hasta 255. Ejemplo
byte b = B10010; // "B" es formateador binario (B10010 = 18 decimal)

int Descripcin Integers (Nmeros enteros) son el principal tipo de datos para almacenar nmeros, y guardan valores de 2 bytes. Esto produce un rango entre -32,768 hasta 32,767 (valor mnimo de -2^15 y un valor mximo de (2^15) - 1). Variables tipo Int, almacenan nmeros negativos con una tcnica llamada Complemento a dos. El bit ms alto, a veces llamado como "sign" bit, indica que el nmero es negativo. Se invierte el valor de cada uno de los bits, es decir, se realiza el complemento a uno, y se suma 1 al nmero obtenido. La placa Arduino, se encarga de tratar con nmeros negativos por t, para que las operaciones aritmticas trabajen de manera transparente y en la forma esperada. Sin embargo, pueden haber complicaciones inesperadas al tratar con el operador right bitshift (>>). Ejemplo
int ledPin = 13;

Syntax
int var = val;

var - nombre de la variable int. val - valor asignado a dicha variable.

Consejo Cuando las variables son hechas para exceder su lmite, stas vuelven a su capacidad mnima, sto sucede en ambas direcciones:
int x x = -32,768; x = x - 1; x = 32,767; x = x + 1;

// x ahora contiene 32,767 - vuelve a // empezar en direccin contraria. // x ahora contiene -32,768 - vuelve a empezar.

unsigned int Descripcin Los enteros sin firma (unsigned int) son los mismos enteros de modo que almacenan un valor de dos bytes. En lugar de almacenar nmeros negativos, slo almacenan valores positivos, generando un rango til desde 0 a 65,535 (2^16 1).

La diferencia entre los enteros sin firma y los enteros (firmados), reside en que el bit ms alto, a veces referenciado como el bit "firmado", es interpretado. En el tipo de dato int de Arduino (que es firmado), si el bit ms alto es "1", el nmero es interpretado como un nmero negativo, y los otros 15 bits son interpretados con complemento a 2. Ejemplo
unsigned int ledPin = 13;

Sintxis
unsigned int var = val;

var - el nombre de tu variable unsigned int val - el valor que asignas a esa variable

Consejo de codificacin Cuando las variables sobrepasan su capacidad mxima dan la vuelta a su mnima capacidad. Ten en cuenta que esto sucede en ambas direcciones.
unsigned int x x = 0; x = x - 1; x = x + 1;

// x ahora contiene 65535 // x ahora contiene 0 - da la vuelta

word Descripcin Una variable tipo word almacena un valor de 16bits sin signo, desde 0 hasta 65535. Es lo mismo que una tipo unsigned int. Ejemplo
word w = 10000;

long Descripcin Las variables de tipo Long son variables de tamao extendido para almacenamiento de nmeros, y 32 bits (4 bytes), desde -2,147,483,648 hasta 2,147,483,647. Ejemplo
long speedOfLight = 186000L; // ver Constantes Integer para // la explicacin de la 'L'

Sintaxis
long var = val;

var - nombre de la variable tipo Long val - valor asignado a la variable

float Descripcion El tipo variable para los nmeros en coma flotante (nmero decimal). Estos nmeros son usados, habitualmente, para aproximar valores analgicos y contnuos, debido a que ofrecen una mayor resolucin que los enteros. Las

variables tipo float tienen el valor mximo 3.4028235E+38, y como mnimo pueden alacanzar el -3.4028235E+38. Ocupan 4bytes (32bits). Los floats tienen una precisin de 6 o 7 dgitos decimales. Esto significa el nmero total de dgitos, no el nmero a la derecha de la coma decimal. Al contrario que en otras plataformas, donde tu podras obtener mayor precisin usando una variable tipo double (por ejemplo, por encima de 15 dgitos), en Arduino los double tienen el mismo tamao que los float. Los nmeros en coma flotante no son exactos, y muchos proporcionan falsos resultados cuando son comparados. Por ejemplo, 6.0 / 3.0 puede no ser igual a 2.0. Debes comprobar que el valor absoluto de la diferencia entre los nmeros pertenezca a un rango pequeo. La matemtica en coma flotante es mucho ms lenta que la matemtica de enteros para realizar operaciones, por lo que deberas evitarla si, por ejemplo, un bucle tiene que ejecutarse a la mxima velocidad para funciones con temporizaciones precisas. Los programadores normalmente suelen asignar unas longitudes para convertir las operaciones de coma flotante en clculos con enteros, para aumentar la velocidad. Ejemplos
float myfloat; float sensorCalbrate = 1.117;

Sintaxis
float var = val;

var - el nombre de la variable tipo float val - el valor que le asignas a esa variable

double Descripcion Nmero en coma flotante de doble precisin. Ocupa 4 bytes.

La implementacin "double" en Arduino es exactamente lo mismo que la FLOAT, sin ganar nada de precisin. Consejo Los usuarios que porten cdigo de otras fuentes y que incluyan variable tipo double deberan examinar el cdigo para ver si la precisin necesaria es diferente a la que se puede lograr en Arduino.

string Descripcin Los strings se representan como arrays de caracteres (tipo char) que terminan con el caracter NULL. Ejemplos Todas las siguientes son declaraciones vlidas de strings.
char char char char char char Str1[15]; Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'}; Str4[ ] = "arduino"; Str5[8] = "arduino"; Str6[15] = "arduino";

Posibilidades de declaracin de strings

Declarar un array de caracteres sin incializarlo como en Str1 Declarar un array de caracteres (con un caracter extra) y el compilador aadir el caracter NULL requerido, como en STR2

Explicitar el caracter NULL, Str3 Inicializar con un string constante entre comillas dobles; el compilador medir el tamao del array para ajustar el string constante y caracter NULL para finalizar, Str4

Inicializar el array con un tamao explcito y un string constante, Str5 Inicializar el array, dejando un espacio extra para un string ms largo, Str6

Terminacin NULL Generalmente, los strings se finalizan con un caracter NULL (cdigo ASCII 0). Esto permite a funciones (como Serial.print()) establecer dnde est el final del string. De otra forma, seguira leyendo los siguientes bytes de la memoria que no forman parte del string. Esto significa que tu string necesita tener espacio para un caracter ms del texto que quieres que contenga. Esto es por lo que Str2 y Str5 necesitan 8 caracteres, incluso aunque "arduino" tenga slo 7 - la ltima posicin es automticamente completada con un caracter NULL. Str4 ser automticamente dimensionada a 8 caracteres, uno para el NULL extra. En Str3, hemos incluido nosotros mismos el caracter NULL (escrito como '\0'). Ten en cuenta que es posible tener un string sin un caracter NULL al final (p.e. si t has especificado la longitud de Str2 como 7 en lugar de 8). Esto romper la mayora de funciones que usen strings, por lo que no deberas hacerlo intencionadamente. Por lo tanto, si detectas algn comportamiento extrao (operando con los caracteres, no con el string), este podra ser el problema.

Comillas simples o dobles Los string siempre se definen entre comillas dobles ("Abc") y los caracteres siempre se definen dentro de comillas simples ('A'). Envolviendo string largos Puedes envolver strings largos de sta manera:
char miString[] = "Esta es la primera linea" " esta es la segunda linea" " etcetera";

Arrays de strings A menudo es conveniente, al trabajar con grandes cantidades de texto, como proyectos con displays LCD, configurar un array de strings. Como los strings son en s mismo arrays, esto es un ejemplo real de un array bidimensional. En el cdigo de abajo, el asterisco despus del tipo de dato char "char*" indica que es un array de "punteros". Todos los nombres de arrays son punteros, por lo que esto es necesario para crear un array de arrays. No es necesario entender punteros en detalle para usarlos con efectividad. Ejemplo
char* miStrings[]={"Este es el string 1", "Este es el string 2", "Este es el string 3", "Este es el string 4", "Este es el string 5","Este es el string 6"}; void setup(){ Serial.begin(9600); } void loop(){ for (int i = 0; i < 6; i++){ Serial.println(miStrings[i]); delay(500); } }

Arrays Una matriz o "array" es una coleccin de variables que son accedidas mediante un nmero de ndice. Los "arrays" en el lenguaje de programacin C, en el cual est basado Arduino, pueden ser complicados, pero usar "arrays" simples es relativamente sencillo. Creando (Declarando) una matriz o Array Todos los mtodos de abajo son formas vlidas de crear (declarar) una matriz.
int myInts[6]; int myPins[] = {2, 4, 8, 3, 6}; int mySensVals[6] = {2, 4, -8, 3, 2}; char message[6] = "hola";

Puedes declarar una matriz sin inicializarla como en myInts. En myPins se declara una matriz sin establecer un tamao explcito. El compilador cuenta el nmero de elementos y crea la matriz con el tamao apropiado. Finalmente, puedes tanto declarar con un tamao la matriz e inicializarla al mismo tiempo, como en mySensVals. Accediendo a una matriz o Array Los Arrays son zero indexed, esto significa que, al referirse a una matriz, el primer elemento de la matriz est en el indice 0. Por lo tanto:

mySensVals[0] == 2, mySensVals[1] == 4,

y sucesivos.

Esto tambin significa que en una matriz con 10 elementos. el indice 9 es el ltimo elemento. Por lo tanto:

int myArray[10]={9,3,2,4,3,2,7,8,9,11}; // myArray[9] contiene 11 // myArray[10] es invalido y contiene informacin aleatoria (de otra direccin de memoria)

Por esta razn hay que tener cuidado en el acceso a las matrices. El acceso ms all del final de una matriz (usando un nmero de ndice mayor que el tamao declarado - 1) resultar la lectura de la memoria que est en uso para otros fines. La lectura de estos lugares probablemente no va a hacer mucho mal, excepto la lectura de datos no vlidos. Escribir en las localidades de memoria aleatoria es definitivamente una mala idea y, a menudo puede conducir a resultados inesperados como fallos o mal funcionamiento del programa. Esto tambin puede ser un error difcil encontrar. A diferencia de BASIC o JAVA, el compilador de C no realiza ninguna comprobacin para ver si el acceso a una matriz est dentro de los lmites del tamao de la matriz que ha declarado. Para asignar un valor a una matriz:
mySensVals[0] = 10;

Matrices y los bucles FOR Las matrices se utilizan muchas veces en el interior de bucles for, donde el contador de bucle se utiliza como el ndice de cada elemento de la matriz. Por ejemplo, para imprimir los elementos de una matriz a travs del puerto serie, se podra hacer algo como esto:
int i; for (i = 0; i < 5; i = i + 1) { Serial.println(myPins[i]); }

Ejemplo Para ver un programa completo que demuestra el uso de los arrays o matrices, mira Knight Rider example desde Tutoriales.

Conversin char() Descripcin: Convierte un valor a un tipo de dato char. Sintaxis: char(x) Parmetros: x: un valor de cualquier tipo Devuelve char

byte() Descripcin: Convierte una variable a un tipo de datos byte. Sintaxis: byte(x) Parmetros: x: una variable de cualquier tipo. Devuelve: byte

int() Descripcin: Convierte un valor al tipo de datos int. Sintaxis: int(x) Parmetros: x: un valor de cualquier tipo. Retorna: int

word() Descripcin: Convierte un valor al tipo de dato word o crea una variable tipo word a partir de dos bytes. Sintaxis: word(x) word(h, l) Parmetros: x: un valor de cualquier tipo. h: el byte ms significativo (el ms a la izquierda) de la palabra. l: el byte menos significativo (el ms a la derecha) de la palabra. Devuelve: Un valor tipo word

long() Descripcin: Convierte un valor al tipo de datos long. Sintaxis: long(x) Parmetros: x: un valor para cualquier tipo Devuelve: long

float() Descripcin: Convierte una variable a tipo float. Sintaxis: float(x) Parmetros: x: una variable de cualquier tipo Devuelve: nmero de coma flotante (float)

mbito de las variables y cualificadores mbito de las variables Las variables en el lenguaje de programacin C, usado por Arduino, tienen una propiedad llamada mbito. Al contrario de lo que pasa en lenguajes como BASIC en los que todas las variables son globales. Una variable global puede verse por todas las funciones de un programa. Las variables locales son slo visibles desde la funcin en las que estn declaradas. En el entorno Arduino, cualquier variable declarada fuera de la funcin (por ejemplo setup(), loop(), etc.), es una variable global. Cuando los programas crecen en tamao y complejidad, las variables globales son una forma til de asegurar que slo una funcin tiene acceso a sus propias variables. Esto previene errores de programacin al evitar que una funcin modifique, involuntariamente, variables de otras funciones. A veces es til declarar e inicializar una variable dentro de un bucle for. Esto crea una variable que slo se puede acceder desde dentro del bucle.

Ejemplo
int gPWMval; void setup() { // ... } void loop() { int i; float f; // ... // cualquier funcin va a tener acceso a esta variable

// "i" es slo accesible dentro de "loop" // "f" es slo accesible dentro de "loop"

for (int j = 0; j <100; j++) { // la variable j slo es accesible desde el bucle ''for'' } }

Static La palabra reservada static se utiliza para crear variables estticas, estas variables tienen la peculiaridad de que no se crean y se destruyen cada vez que se llama al bloque de cdigo en el que est definidas, sino que su valor se guarda para las sucesivas llamadas. Las variables que se declaran como estticas slo se crearan e inicializarn la primera vez que se ejecute el bloque de cdigo en el que estn contenidas.

Ejemplo
/* RandomWalk * Paul Badger 2007 * RandomWalk salta aleatoriamente entre 2 puntos de salida * El mximo est controlado por el parmetro "stepsize". * Una variable esttica es incrementada o decrementada aleatoriamente. * Esta tcnica es conocida como "pink noise" y "drunken walk". */

#define randomWalkLowRange -20 #define randomWalkHighRange 20 int stepsize; int thisTime; int total; void setup() { Serial.begin(9600); } void loop() { // lanzamos la funcin randomWalk stepsize = 5; thisTime = randomWalk(stepsize); Serial.println(thisTime); delay(10); } int randomWalk(int moveSize) { static int place; // variable esttica los valores se conservaron // entre las siguientes llamadas a la funcin. // Ninguna otra funcin puede cambiar su valor place = place + (random(-moveSize, moveSize + 1)); if (place < randomWalkLowRange) { // comprueba el lmite mayor y el menor place = place + (randomWalkLowRange - place); // modifica el nmero a una direccin positiva } else if(place > randomWalkHighRange) { place = place - (place - randomWalkHighRange); // modifica el nmero a una direccin negativa } return place; }

Palabra clave volatile volatile es una palabra clave conocida como variable clasificada (qualifier), se utiliza habitualmente delante de un tipo de datos, para modicar la forma en la que el compilador y el correspondiente programa trata la variable.

Declarar un variable como voltil es una directiva para el compilador. El compilador es un software que traduce tu cdigo C/C++ en cdigo mquina, que son las instrucciones reales para el chip Atmega de la Arduino. Especficamente, dirige al compilador para cargar la variable desde memoria RAM y no desde un registro de almacenamiento, que es una localizacin de memoria temporal donde las variables se almacenan y son manipuladas. Bajo ciertas condiciones, el valor de la variable almacenada en registros puede ser imprecisa. Una variable debe ser declarada volatile siempre que su valor pueda ser modificado por algo ms all de la seccin del cdigo en el que aparece, como por ejemplo un hilo de ejecucin concurrente. En Arduino, el nico lugar en el que se podra dar el caso es en secciones de cdigo asociadas a interrupciones, denominadas rutina de servicio de interrupcin (interrupt service routine). Ejemplo
// Conmuta el LED cuando el pin de interrupcin cambia de estado int pin = 13; volatile int estado = LOW; void setup() { pinMode(pin, OUTPUT); attachInterrupt(0, parpadea, CHANGE); } void loop() { digitalWrite(pin, estado); } void parpadea() { estado = !estado; }

La palabra clave (keyword) const La palabra clave const se refiere a una constante. Es un qualificador de variable que modifica el comportamiento de la misma, haciendo una variabe de "slolectura". Significa que la variable puede ser usada como cualquiera de su tipo, pero su valor no puede ser modificado. Obtendrs un error de compilacin si intentas asignar un valor a una variable const. Las constantes definidas con la palabra clave const obedecen a las reglas de mbito de las variables que rigen otras variables. Esto, y los escollos de usar #define, hace de la palabra clave const un mtodo superior para definir constantes y es preferible a usar #define. Ejemplo
const float pi = 3.14; float x; // .... x = pi * 2; pi = 7; // Es correcto usar una const en una operacin // Ilegal - No puedes escribir (modificar) una constante

#define o const Puedes usar cualquiera const o #define para crear constantes de cadenas o nmeros. Para matriz, necesitars usar const. En general es preferible usar const que #define para definir constantes.

Utilidades sizeof

Descripcion El operador sizeof devuelve el nmero de bytes de un tipo de variable, o el nmero de bytes que ocupan un array. Sintaxis sizeof(variable) Parametros variable: cualquier tipo de variable o array (p.e. int, float, byte) Cdigo de ejemplo El operador sizeof es til para tratar con array (tales como strings) donde es conveniente poder cambiar el tamao del array sin romper otras partes del programa. Este programa imprime un texto caracter a caracter. Prueba a cambiar el texto de la frase
char miStr[] = "esto es una prueba"; int i; void setup(){ Serial.begin(9600); } void loop() { for (i = 0; i < sizeof(miStr) - 1; i++){ Serial.print(i, DEC); Serial.print(" = "); Serial.println(miStr[i], BYTE); } }

Ten en cuenta que sizeof devuelve el nmero total de bytes. Por lo que tipos de variables ms grandes como enteros (int), el bucle for podra parecerse a algo como esto.

for (i = 0; i < (sizeof(miInts)/sizeof(int)) - 1; i++) { // haz algo con miInts[i] }

Funciones E/S digital pinMode() Descripcin Configura el pin especificado para comportarse como una entrada o una salida. Sintaxis: pinMode(pin, modo) Parametros pin: el numero del pin que se desea configurar modo: INPUT (Entrada) o OUTPUT (Salida) Devuelve: Nada

Ejemplo
int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); } // LED conectado al pin digital 13

//configura el pin del LED como salida

// // // //

Enciende el LED espera un segundo Apaga el LED Espera un segundo

Nota Una entrada analgica puede ser usada como un pin digital, refirindose a ellos desde el nmero 14 (entrada analgica 0) a 19 (entrada analgica 5).

digitalWrite() Descripcin Escribe un valor HIGH o LOW hacia un pin digital. Si el pin ha sido configurado como OUTPUT con pinMode(), su voltaje ser establecido al correspondiente valor: 5V ( o 3.3V en tarjetas de 3.3V) para HIGH, 0V (tierra) para LOW. Si el pin es configurado como INPUT, escribir un valor de HIGH con digitalWrite() habilitar una resistencia interna de 20K conectada en pullup (ver el tutorial de pines digitales). Escribir LOW invalidar la resistencia. La resistencia es sufuciente para hacer brillar un LED de forma opaca, si los LEDs aparentan funcionar, pero no muy iluminados, esta puede ser la causa. La solucin es establecer el pin como salida con la funcin pinMode(). NOTA: El pin digital nmero 13 es ms difcil de usar que los otros pines digitales por que tiene un LED y una resistencia adjuntos, los cuales se encuentran soldados a la tarjeta, y la mayora de las tarjetas se encuentran as. Si habilitas la resistencia interna en pullup, proporcionar 1.7V en vez de los 5V esperados, por que el LED soldado en la tarjeta y resistencias bajan el nivel de voltaje, significando que siempre regresar LOW. Si debes usar el pin nmero 13 como entrada digital, usa una resistencia externa conectada a pulldown.

Sintaxis: digitalWrite(pin, valor) Parameters pin: el nmero de pin valor: HIGH o LOW Devuelve: nada Ejemplo
int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); } // LED conectado al pin digital 13

// establece el pin digital como salida

// // // //

enciende el LED espera por un segundo apaga el LED espera por un segundo

Establece el pin nmero 13 a HIGH, hace un retraso con la duracin de un segundo, y regresa el pin a LOW.

digitalRead() Descripcin: Lee el valor de un pin digital especificado, HIGH o LOW. Sintaxis: digitalRead(pin) Parmetros: pin: el nmero de pin digital que quieres leer (int) Devuelve: HIGH o LOW

Ejemplo
int ledPin = 13; // LED conecado al pin digital nmero 13 int inPin = 7; // botn (pushbutton) conectado al pin digital nmero 7 int val = 0; // variable donde se almacena el valor ledo void setup() { pinMode(ledPin, OUTPUT); pinMode(inPin, INPUT); } void loop() { val = digitalRead(inPin); digitalWrite(ledPin, val); }

// pin digital nmero 13 como salida // pin digital nmero 7 como entrada

// leer el pin de entrada // establece el LED al valor del botn

Establece el pin nmero 13 al mismo valor que el pin nmero 7, que es una entrada. Nota: Si el pin no esta conectado a algo, digitalRead() puede regresar HIGH o LOW (y esto puede cambiar aleatoriamente). Los pines analogicos pueden ser usados como pines digitales con los nmeros 14 (entrada analogica nmero 0) hasta 19 (entrada analogica nmero 5).

E/S analgica analogReference(tipo) Descripcin Configura el voltaje de referencia usado por la entrada analgica. La funcin analogRead() devolver un valor de 1023 para aquella tensin de entrada que sea igual a la tensin de referencia. Las opciones son:

DEFAULT: Es el valor de referencia analgico que viene por defecto que es de 5 voltios en placas Arduino y de 3.3 voltios en placas Arduino que funcionen con 3.3 voltios.

INTERNAL: Es una referencia de tensin interna de 1.1 voltios en el ATmega168 o ATmega328 y de 2.56 voltios en el ATmega8.

EXTERNAL: Se usar una tensin de referencia externa que tendr que ser conectada al pin AREF.

Parmetros tipo: El tipo de referencia que se desea usar (DEFAULT, INTERNAL, or EXTERNAL). Devuelve: Nada. Precaucin Es recomendable que cuando se use la referencia de tensin externa se conecte al pin AREF usando una resistencia de 5K. Esto evitar posibles daos internos en el ATmega si la configuracin de la referencia analgica es incompatible con el montaje fsico que se ha llevado a cabo. Tenga en cuenta que esa resistencia afectar la tensin que se use como tensin de referencia ya que el pin AREF posee una resistencia interna de 32K. Ambas resistencias forman un divisor de tensin, por lo tanto, si por ejemplo se conecta una tensin de 2.5V con la resistencia de 5K la tensin que se utilice como tensin de referencia ser de 2.2V ya que esa ser la tensin que caiga en el pin AREF debido al divisor de tensin al que se ha hecho referencia. El conectar la tensin de referencia externa a travs de una resistencia permite pasar mediante software de usar tensin de referencia interna a una tensin de referencia externa sin que la configuracin fsica del hardware nos afecte la configuracin actual del conversor A/D.

Uso del pin AREF La tensin aplicada en el pin AREF ser la que haga que el conversor A/D de su mxima lectura (1023) cuando lea una tensin igual a la aplicada en ese pin. Tensin por debajo de esa tensin conectada a AREF ser escalada proporcionalmente, as cuando se usa la tensin de referencia por defecto (DEFAULT) el valor que nos devuelve una tensin de 2.5V en una entrada analgica ser 512. La configuracin por defecto del Arduino es la de no tener nada conectado de forma externa al pin AREF (El pin 21 del chip ATmega). En este caso la configuracin de la tensin de referencia sera DEFAULT lo cual conecta AVCC (Alimentacin positiva +5V) de forma interna al pin AREF. Este pin es un pin de baja impedancia (mucha corriente) por lo que si usando la configuracin DEFAULT de la tensin de referencia se conecta otra tensin que no sea la que posee AVCC, podria daar el chip ATmega. El pin AREF tambin puede conectarse de forma interna a una fuente de referencia de 1.1 voltios (o 2.54 en los ATmega8) usando el comando analogReference(INTERNAL).Con esta configuracin las tensiones aplicada a los pines analgicos que sean iguales a la tensin de referencia interna o superior nos devolvern 1023 cuando se lleva a cabo su lectura con la funcin analogRead(). Tensiones ms bajas devolvern valores proporcionales, por ejemplo, si tenemos una tensin de 0.55 voltios en el pin analgico, nos devolver 512. La conexin entre la fuente de 1.1 voltios y el pin AREF es de muy alta impedancia (baja corriente), por lo que la lectura de la tensin de 1.1 voltios solo se podr hacer con un multmetro que tenga alta impedancia de entrada. Si se aplicase por error una tensin de referencia externa en el pin AREF mientras se est usando la configuracin INTERNAL para la tensin de referencia, no daar el chip pero har que la tensin de referencia sea la externa y no la de 1.1 voltios de la fuente interna. An as es recomendable que cualquier tensin externa que se conecte al

pin AREF se haga a travs de una resistencia de 5K para evitar el problema mencionado arriba. La correcta configuracin del software cuando se utiliza una tensin de referencia externa se hace mediante la funcin analogReference(EXTERNAL). Eso desconectar ambas tensin de referencia internas del pin AREF y por tanto ser la externa la cual gobierne la tensin mxima leda por el ADC.

analogWrite() Descripcin Escribe un valor analgico (PWM) en un pin. Puede ser usado para controlar la luminosidad de un LED o la velocidad de un motor. Despus de llamar a la funcin analogWrite(), el pin generar una onda cuadrada estable con el ciclo de trabajo especificado hasta que se vuelva a llamar a la funcin analogWrite() (o una llamada a las funciones digitalRead() o digitalWrite() en el mismo pin). La frecuencia de la seal PWM sera de aproximadamente 490 Hz. En la mayora de las placas Arduino (aquellas con el ATmega168 o ATmega328), se podr generar seales PWM en los pines 3, 5, 6, 9, 10, y 11. En la placa Arduino Mega, se puede llevar a cabo con los pines desde el 2 hasta el pin 13. Las placas Arduino ms antiguas que posean el chip ATmega8 solo podrn usar la funcin analogWrite() con los pines 9, 10 y 11. No hace faltar configurar el pin como salida para poder usar la funcin analogWrite(). La funcin analogWrite no tienen ninguna relacin con los pines de entrada analgicos ni con la funcin analogRead.

Sintaxis: analogWrite(pin, valor) Parmetros pin: Es el pin en el cual se quiere generar la seal PWM. valor: El ciclo de trabajo deseado comprendido entre 0 (siempre apagado) y 255 (siempre encendido). Devuelve: Nada Notas y problemas conocidos. Las seales PWM generadas en los pines 5 y 6 poseern ciclos de trabajo superiores a lo esperado. Porque para esos dos pines se utiliza el mismo temporizador que se utiliza en las funciones millis() y delay(). Este efecto se notar mucho ms en ciclos de trabajo bajos (por ejemplo de 0 a 10) y puede ser que aunque configuremos esos pines con una seal de ciclo de trabajo cero no llegue a ser verdaderamente 0. Ejemplo Produce una seal donde conectamos el LED, cuyo ciclo de trabajo es proporcional a la tensin leda en el potencimetro.
int ledPin = 9; int analogPin = 3; int val = 0; // LED conectado al pin digital 9 // potencimetro conectado al pin 3 // variable en el que se almacena el dato ledo // sets the pin as output

void setup() { pinMode(ledPin, OUTPUT); }

void loop() { val = analogRead(analogPin); analogWrite(ledPin, val / 4);

// lee la tensin en el pin // valores de analogRead van de 0 a // 1023 y los valores de analogWrite // van desde 0 a 255, por eso ajustamos // el ciclo de trabajo al valor ledo. // dividido por 4.

analogRead() Descripcin Lee el valor de tensin en el pin analgico especificado. La placa Arduino posee canales conectados a un conversor analgico digital de 10 bits. Esto significa que convertir tensiones entre 0 y 5 voltios a un nmero entero entre 0 y 1023. Esto proporciona una resolucin en la lectura de: 5 voltios / 1024 unidades, es decir, 0.0049 voltios (4.9 mV) por unidad. El rango de entrada puede ser cambiado usando la funcin analogReference(). El conversor tarda aproximadamente 100 microsegundos (0.0001 segundos) en leer una entrada analgica por lo que se puede llevar una tasa de lectura mxima aproximada de 10.000 lecturas por segundo. Sintaxis: analogRead(pin) Parmetros pin: Indica el nmero del pin de la entrada analgica que deseamos leer (0 a 5 en la mayora de las placas, de 0 a 7 en las Mini y Nano y de 0 a 15 en las Mega) Devuelve int (0 a 1023) Nota Si la entrada analgica que vamos a leer no est conectada a nada, el valor que devolver la funcin analogRead() fluctuar dependiendo de muchos valores (los valores de otras entradas analgicas, que tan cerca est tu mano de la entrada en cuestin, etc.)

Ejemplo
int analogPin = 3; // el pin analgico 3 conectado al dial de // un potencimetro los terminales exteriores // del potencimetro conectados a +5V y masa // respectivamente // declaracin de la variable en la que se almacenar // el valor ledo por el conversor.

int val = 0;

void setup() { Serial.begin(9600); } void loop() { val = analogRead(analogPin); Serial.println(val); }

//

Inicializacin del modulo Serial.

// lee el valor de tensin del pin // enva el valor leido va serial.

E/S avanzada tone() Descripcin Genera una onda cuadrada de la frecuencia especificada (y un 50% de ciclo de trabajo) en un pin. La duracin puede ser especificada, en caso contrario la onda continua hasta que haya una llamada a noTone(). El pin puede conectarse a un zumbador piezoelctrico u otro altavoz que haga sonar los tonos. Slo puede generarse un tono cada vez. Si un tono est sonando en un pin diferente, la llamada a tone() no tendr efecto. Si el tono est sonando en el mismo pin, la llamada establecer la nueva frecuencia. El uso de la funcin tone() interferir con la salida PWM en los ins 3 y 11 (en otras placas distintas de la Mega).

NOTA: si quieres hacer sonar diferentes tonos en mltiples pins necesitas llamar a noTone() en un pin antes de llamar a tone() en el siguiente pin. Sintxis tone(pin, frecuencia) tone(pin, frecuencia, duracion) Parmetros pin: el pin en el que generar el tono frecuencia: la frecuencia del tono en hercios. duracion: la duracin del tono en milisegundos (opcional) NOTA: las frecuencias audibles por el odo humano van de los 20Hz a los 20KHz por lo que el parmetro "frecuencia" debera estar comprendido entre estos dos valores. Retorno: Ninguno

noTone()
Descripcin Detiene la generacin de la seal cuadrada que se activa al hacer uso de la funcin tone(). No tiene efecto si no se est generando ningn tono. NOTA: si quieres generar tonos diferentes en mltiples pines, necesitas usar la funcin noTone() en el pin antes de llamar a la funcin tone() en el siguiente pin.

Sintaxis: noTone(pin) Parmetros: pin: el pin en el cual se va a parar de generar el tono. Devuelve: Nada

shiftOut() Descripcin Desplaza un byte de datos bit a bit. Empieza desde el bit ms significante (el de ms a la izquierda) o el menos significante (el ms a la derecha). Cada bit se escribe siguiendo su turno en un pin de datos, despus de conmutar un pin de reloj (seal de reloj) para indicar que el bit est disponible. Esto es conocido como protocolo serie sncrono y es la forma comn que utilizan los microcontroladores para comunicarse con sensores y con otros y se

microcontroladores.

Ambos

dispositivos

permanecen

sincronizados,

comunican a velocidades cercanas a las mximas, hasta que ambos compartan la misma linea de reloj. En la documentacin del harware interno de los chips se hace referencia a menudo a esta caracterstica como Serial Peripheral Interface (SPI). Sintaxis: shiftOut(pinDatos, pinReloj, ordenBits, valor) Parametros pinDatos: el pin en el cual extraer cada bit (int) pinReloj: el pin que hay que conmutar cada vez que a un pinDatos le ha sido enviado el valor correcto (int)

ordenBits: en qu orden desplazar los bits; si hacia el MSBFIRST (bit ms significante primero) o hacia el LSBFIRST (bit menos significante primero). valor: los datos que rotar. (byte) Retorno: Ninguno Nota El pinDatos y pinReloj deben estar ya configurados como salida con una llamada previa a pinMode(). shiftOut se encuentra actualmente configurada para extraer un byte (8 bits) por lo que necesita realizar una operacin de dos pasos para extraer valores ms grandes de 255.
// Haz esto para una comunicacin serie MSBFIRST (primero el bit // ms significativo). int datos = 500; // rota el byte ms alto shiftOut(pinDatos, pinReloj, MSBFIRST, (datos >> 8)); // rota el byte ms bajo shiftOut(datos, pinReloj, MSBFIRST, datos); // O haz esto para una comunicacin serie LSBFIRST (primero el bit // menos significativo). datos = 500; // rota el byte ms bajo shiftOut(pinDatos, pinReloj, LSBFIRST, datos); // rota el bit ms alto shiftOut(pinDatos, pinReloj, LSBFIRST, (datos >> 8));

Ejemplo Para ver el circuito asociado a este ejemplo, ver el tutorial para controlar un registro de desplazamiento 74HC595.
//**************************************************************//

// Name : shiftOutCode, Hello World // // Author : Carlyn Maw,Tom Igoe // // Date : 25 Oct, 2006 // // Version : 1.0 // // Notes : Cdigo para utilizar un registro de desplazamiento// // : 74HC595 para contar de 0 a 255 // //**************************************************************** //Pin conectado al pin ST_CP del 74HC595 int latchPin = 8; //Pin connectado al pin SH_CP del 74HC595 int clockPin = 12; //Pin conectado al pin DS del 74HC595 int dataPin = 11; void setup() { // Configura como salida los pines que se direccionan // en el bucle principal (loop) pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } void loop() { //rutina de conteo for (int j = 0; j < 256; j++) { //pone a nivel bajo el latchPin y lo mantienen a nivel bajo todo // el tiempo que ests transmitindo digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, j); //vuelve a poner el latchPin a nivel alto para sealizar que //no sigue siendo necesario eschuchar ms informacin digitalWrite(latchPin, HIGH); delay(1000); } }

pulseIn()
Descripcin Lee un pulso (ya sea HIGH o LOW) en un pin. Por ejemplo, si value es HIGH, pulseIn() espera a que el pin sea HIGH, empieza a cronometrar, espera a que el pin sea LOW y entonces detiene la medida de tiempo. Devuelve la anchura del pulso en microsegundos. Interrumpe la medida y devuelve 0 si el pulso no ha comenzado en un tiempo especificado. La medida del tiempo en esta funcin ha sido determinada de forma emprica y est sujeta a errores en pulsos largos. Funciona correctamente en pulsos con una anchura comprendida de 10 microsegundos a tres minutos. Sintaxis pulseIn(pin, value) pulseIn(pin, value, timeout)

Parmetros pin: el nmero del pin en el que se realiza la medida del pulso. (int) value: tipo de pulso. Puede ser HIGH o LOW. (int) timeout (opcional): el tiempo en microsegundos mximo a esperar antes de que se inicie el pulso. (unsigned long)

Devuelve el ancho del pulso (en microsegundos) 0 si el pulso no ha empezado antes del timeout (unsigned long)

Ejemplo
int pin = 7; unsigned long duracion; void setup() { pinMode(pin, INPUT); } void loop() { duracion = pulseIn(pin, HIGH); }

Tiempo millis()
Descripcin Devuelve el tiempo en milisegundos transcurridos desde que se arranco la placa Arduino con el programa actual. Este nmero de desbordar (volver a cero), despus de aproximadamente 50 das. Parmetros: Ninguno Devuelve: Tiempo en milisegundos desde que el programa se inici (long sin signo (unsigned long)) Ejemplo
unsigned long time; void setup(){ Serial.begin(9600); } void loop(){ Serial.print("Tiempo: "); time = millis(); //Imprime el tiempo desde que se inici el programa Serial.println(time); // espera un segundo para no enviar demasiados datos delay(1000); }

Consejo: Ten en cuenta que el parametro que devuelve millis() es un long sin signo por lo que pueden producirse errores si el programador intenta llevar a cabo operaciones matemticas con otros tipos de dato como enteros.

micros() Descripcin Devuelve el nmero de microsegundos desde que la placa Arduino comenz a correr el programa. Este nmero eventualmente volver a 0 (overflow), luego de aproximadamente 70 minutos. A 16 MHz, en las placas Arduino (por ejemplo, Duemilanove Nano), stas funcin tiene una resolucin de cuatro milisegundos (por ejemplo, el valor devuelto es siempre mltiplo de 4). A 8 MHz, en placas Arduino (como LilyPad), tiene una resolucin de 8 microsegundos. Nota: En un milisegundo hay 1.000 microsegundos y 1,000,000 microsegundos en un segundo. Parmetros: Ninguno. Devuelve: El nmero de microsegundos desde el inicio del programa (unsigned long) Ejemplo
unsigned long time; void setup(){ Serial.begin(9600); } void loop(){ Serial.print("Tiempo: "); time = micros(); //Imprime el tiempo desde el comienzo del programa Serial.println(time); // espera un segundo para no enviar datos una cantidad exagerada de datos. delay(1000); }

delay() Descripcin Pausa el programa por un tiempo determinado (en milisegundos) especificado por un parmetro. Hay 1000 milisegundos en un segundo. Sintaxis: delay(ms) Parmetros: ms: el nmero de milisegundos que se desea pausar el programa (unsigned long) Devuelve: nada Ejemplo
int ledPin = 13; // LED conectado al pin digital 13.

void setup() { pinMode(ledPin, OUTPUT); // declara que el pin digital se va a usar como salida } void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); }

// // // //

enciende el LED espera durante un segundo apaga el LED espera durante un segundo

Advertencia Aunque es fcil crear un LED parpadeante con la funcin delay() y muchos sketches usan pausas cortas para estas tareas, el uso de delay() en un sketch tiene problemas importantes. Mientras se pausa el programa no se leen sensores, ni se hacen clculos, ni puede haber manipulacin de los pines. En definitiva, hace que (casi) toda la actividad se pare. Una alternativa para controlar el tiempo es el uso de la funcin millis() y el sketch mostrado abajo. Normalmente se evita el uso de delay() para tiempos mayores de decenas de milisegundos excepto en programas muy simples.

Algunas cosas siguen funcionando mientras se ejecuta la funcin delay() porque no se deshabilitan las interrupciones. La comunicacin serie de los pines RX sigue funcionando, los valores de PWM (analogWrite) y los estados de los pines se mantienen y las interrupciones siguen funcionando correctamente.

delayMicroseconds() Descripcin Detiene brevemente el programa por la cantidad en tiempo (en microsegundos) especificada como parmetro. Actualmente, el valor ms grande producir un retraso exacto es 16383. Esto puede cambiar en una futura versin de Arduino. Para retrazos ms largos que algunos miles de microsegundos, deberas usar delay() . Sintaxis: delayMicroseconds(us) Parametros: us: el nmero de microsegundos a detener (unsigned int) Devuelve: Nada Ejemplo
int outPin = 8; void setup() { pinMode(outPin, OUTPUT); } void loop() { digitalWrite(outPin, HIGH); delayMicroseconds(50); digitalWrite(outPin, LOW); delayMicroseconds(50); } // selecciona el pin 8

// establece el pin digital como salida

// // // //

establece en encedido el pin espera por 50 microsegundos establece en apagado el ping espera por 50 microsegundos

configura el pin nmero 8 para trabajar como pin de salida. Envia una serie de pulsos con 100 microsegundos de perodo. Advertencias y problemas conocidos Esta funcin trabaja de manera exacta en el rango de 3 microsegundos y valores superiores. No podemos asegurar que la funcin dealyMicroseconds funcionar de forma precisa para valores menores de retraso. A partir de Arduino 0018, delayMicroseconds() ya no invalida las interrupciones

Clculo min(x, y) Descripcin: Calcula el mnimo de dos nmeros. Parametros: x: el primer nmero, cualquier tipo de dato y: el segundo nmero, cualquier tipo de dato Devuelve: El ms pequeo entre los dos nmeros.

Ejemplos
sensVal = min(sensVal, 100); // asigna sensVal al menor entre sensVal y 100 // asegurando que nunca pasar de 100.

Nota La funcin max() es usualmente usada para limitar el lmite inferior del rango de una variable, mientras que la funcin min() es usada para limitar el lmite superior del rango de una variable. Advertencia Debido a la forma en la que se ha implementado la funcin min(), evite realizar operaciones en el argumentos de la funcin ya que podra producir errores.
min(a++, 100); a++; min(a, 100); // evite esto - puede producir errores // use este mtodo en cambio - mantenga cualquier // operacin fuera de los parntesis

max(x, y) Descripcin: Calcula el mximo de dos nmeros. Parmetros x: El primer nmero, cualquier tipo de dato. y: El segundo nmero, cualquier tipo de dato. Devuelve: El mayor de ambos parmetros. Ejemplo
sensVal = max(senVal, 20); // asigna a sensVal su propio valor o, de ser superior, 20. // (una forma efectiva de asegurar que el valor mnimo de senVal sea 20)

Nota max() suele ser usado para restringir el valor ms bajo del rango de una variable, mientras que min() es utilizado para restringir el valor mximo del rango.

Atencin Debido a la forma en que la funcin max() es implementada, debes evitar usar otras funciones al definir los parmetros, puede derivar en resultados incorrectos.
max(a--, 0); a--; max(a, 0); // evitar esto - puede dar resultados incorrectos. // en su lugar, hacerlo as // mantener cualquier operacin fuera de los parntesis.

abs(x) Descripcin: Calcula el valor absoluto de un nmero. Parmetros. x: El numero cuyo valor absoluto deseamos calcular Devuelve x: si x is mayor o igual que 0. -x: si x es menor que 0. Precaucin Debido a la forma en la que se ha implementado la funcin abs(), evite usar otras funciones como parmetro debido a que puede ocasionar que se devuelva un resultado incorrecto.
abs(a++); a++; abs(a); // evite esto - produce errores en el resultado // hazlo de esta manera // mantenga cualquier otra operacin fuera de la funcin

constrain(x, a, b) Descripcin: Restringe un nmero a un rango definido. Parmetros x: el nmero a restringir, cualquier tipo de datos. a: El nmero menor del rango, cualquier tipo de datos. b: El nmero mayor del rango, cualquier tipo de datos. Retorna x: si x est entre a y b a: si x es menor que a b: si x es mayor que b Ejemplo
sensVal = constrain(sensVal, 10, 150); // limita el valor del sensor entre 10 y 150

map(value, fromLow, fromHigh, toLow, toHigh) Descripcin Re-mapea un nmero desde un rango hacia otro. sto significa que, un valor (value) con respecto al rango fromLow-fromHight ser mapeado al rango toLowtoHigh. No se limitan los valores dentro del rango, ya que los valores fuera de rango son a veces objetivos y tiles. La funcin constrain() puede ser usada tanto antes como despus de sta funcin, si los lmites de los rangos son deseados.

Ten en cuenta que los lmites "inferiores" de algn rango pueden ser mayores o menores que el lmite "superior" por lo que map() puede utilizarse para revertir una serie de nmeros, por ejemplo:
y = map(x, 1, 50, 50, 1);

La funcin maneja correctamente tambin los nmeros negativos, por ejemplo:

y = map(x, 1, 50, 50, -100);

tambin es vlido y funciona correctamente. La funcin map() usa matemtica de enteros por lo que no generar fracciones, aunque fuere el resultado correcto. Los resultados en fracciones se truncan, y no son redondeados o promediados. Parmetros value: el nmero (valor) a mapear. fromLow: el lmite inferior del rango actual del valor. fromHigh: el lmite superior del rango actual del valor. toLow: lmite inferior del rango deseado. toHigh: lmite superior del rango deseado. Devuelve: El valor mapeado. Ejemplo
/* Mapea un valor anlogo a 8 bits (0 a 255) */ void setup() {} void loop() { int val = analogRead(0); val = map(val, 0, 1023, 0, 255); analogWrite(9, val); }

Apndice
Para los interesados en el funcionamiento de la funcin, aqu est su cdigo:
long map(long x, long in_min, long in_max, long out_min, long out_max) { return (x - in_min) * (out_max - out_min) / (in_max - in_min) out_min; }

pow(base, exponente) Descripcin Calcula el valor de un nmero elevado a otro nmero. Pow() puede ser usado para elevar un nmero a una fraccin. Esta funcin es til para generar datos exponenciales o curvas. Parmetros base: base que queremos elevar (float) (Coma flotante) exponente: la potencia a la que se quiere elevar la base (float) (Coma flotante) Devuelve: El resultado de la exponenciacin (double)(Doble) Ejemplo. Mira la funcin fscale en la librera del cdigo.

sqrt(x) Descripcin: Calcula la raz cuadrada de un numero. Parmetros. x: el numero, cualquier tipo de dato Devuelve: doble, la raz cuadrada del numero.

Trigonometra
sin(rad) Descripcin: Calcula el seno de un ngulo (en raianes). El resultado ser entre -1 y 1. Parametros. rad: el ngulo en radianes (float) Retorno: El seno del ngulo (double) Nota: Serial.print() y Serial.println() no soportan la impresin de valores tipo float.

cos(rad) Descripcin: Calcula el coseno de un ngulo (en radianes). El resultado estar entre -1 y 1. Parmetros. rad: el ngulo en radianes (float) Retorna: El coseno del ngulo ("double") Nota: Serial.print() y Serial.println() no soportan actualmente la impresin de nmeros con decimales.

tan(rad) Descripcin. Calcula la tangente de un ngulo (en radianes). El resultado estar entre el menos infinito y el infinito. Parmetros. rad: el ngulo en radianes (float). Retorno. La tangente del ngulo (double)

Nota. Serial.print() y Serial.println() no soportan actualmente imprimir variales de tipo float.

Nmeros aleatorios randomSeed(seed) Descripcin randomSeed() inicializa el generador de nmeros pseudoaleatorios, hacindole empezar en un punto arbitrario de su secuencia aleatoria. Esta secuencia, aunque muy larga y aleatoria, es siempre la misma. Si es importante que la secuencia de valores generada por random() difiera en ejecuciones sucesivas de un programa, es recomendable utilizar randomSeed() (seed en ingls, semilla) para inicializar el generador de nmeros aleatorios con una entrada mnimamente aleatoria como analogRead() en un pin desconectado. No obstante, puede ser til usar secuencias pseudoaleatorias que se repitan exactamente. Esto se consigue llamando a randomSeed() con un nmero fijo antes de empezar la generacin de la secuencia. Parmetros. long, int - recibe un nmero para generar la semilla. Devuelve. no devuelve nada Example
long numAleatorio; void setup(){ Serial.begin(9600); randomSeed(analogRead(0)); } void loop(){ randNumber = random(300); Serial.println(numAleatorio); delay(50);}

random() Descripcin La funcin random genera nmeros pseudoaleatorios. Sintaxis random(max) random(min, max) Parmetros min - lmite inferior del valor aleatorio, inclusive (opcional) max - lmite superior del valor aleatorio, exclusive (se devuelve hasta el anterior) Devuelve: un nmero aleatorio entre min y max (long) Nota: Si es importante que la secuencia de valores generada por random() difiera en ejecuciones sucesivas de un programa, es recomendable utilizar randomSeed() (seed en ingls, semilla) para inicializar el generador de nmeros aleatorios con una entrada mnimamente aleatoria como analogRead() en un pin desconectado. No obstante, puede ser til usar secuencias pseudoaleatorias que se repitan exactamente. Esto se consigue llamando a randomSeed() con un nmero fijo antes de empezar la generacin de la secuencia. Ejemplo
long numAleatorio; void setup(){ Serial.begin(9600); // si la entrada analgica 0 no est conectada, // la llamada a randomSeed() recibir ruido esttico // (analgico) y se generarn diferentes semillas // cada vez que se ejecute el sketch. randomSeed(analogRead(0)); }

void loop() { // escribe un nmero aleatorio de 0 a 299 numAleatorio = random(300); Serial.println(numAleatorio); // escribe un nmero aleatorio de 10 a 19 numAleatorio = random(10, 20); Serial.println(numAleatorio); delay(50); }

Bits y bytes lowByte() Descripcin: Extrae el byte de orden inferior (derecha) de una variable (por ejemplo, una palabra). Sintaxis: lowByte(x) Parmetros. x: un valor de cualquier tipo. Devuelve: byte

highByte() Descripcin. Extrae el byte de orden superior (el ms a la izquierda) de una palabra (o del segundo byte ms bajo de un tipo de dato largo) Sintaxis. highByte(x). Parametros. x: un valor de cualquier tipo.

Retorna: byte

bitRead() Descripcin. Lee un bit de un nmero. Sintaxis: bitRead(x, n) Parmetros x: el nmero en el que queremos leer n: cual de los bits queremos leer, empezando por el 0 para el bit menos significativo (el que est ms a la derecha) Devuelve: el valor del bit (0 o 1).

bitWrite() Descripcin. Escribe un bit de una variable numrica. Sintaxis: bitWrite(x, n, b) Parmetros x: la variable numrica en la que vamos a escribir n: en cual de los bits vamos a escribir, empezando en el 0 para el bit menos significativo (el que est ms a la derecha) b: el valor a escribir en el bit (0 o 1) Devuelve: nada

bitSet() Descripcin: Pone a uno un bit de una variable numrica. Sintaxis: bitSet(x, n) Parmetros x: la variable numrica en la que est el bit a poner a uno n: cual de los bits queremos poner a uno, empezando en el 0 para el bit menos significativo (el que est ms a la derecha) Devuelve: nada

bitClear() Descripcin: Limpia (pone a cero) un bit de una variable numrica. Sintaxis: bitClear(x, n) Parmetros x: la variable numrica con el bit a limpiar n: cual de los bits queremos limpiar, empezando en el 0 por el bit menos significativo (el que est ms a la derecha) Devuelve: nada

bit() Descripcion: Calcula el valor del bit especificado (bit 0 es el 1, bit1 es el 2, bit2 es 4, etc.). Sintaxis: bit(n) Parmetros. n: el bit cuyo valor se quiere calcular. Devuelve: El valor del bit.

Interrupciones externas attachInterrupt(interrupcion, funcion, modo) Descripcin Especifica la funcin a la que invocar cuando se produce una interrupcin externa. Reemplaza cualquier funcin previa que estuviera enlazada a la interrupcin. La mayora de las placas Arduino tienen dos interrupciones externas: Las nmero 0 (en el pin digital 2) y la 1 (en el pin digital 3). La Arduino Mega tiene otras cuatro: Las nmero 2 (pin 21), 3 (pin 20), 4 (pin 19) y 5 (pin 18). Parmetros interrupcion: el nmero de la interrupcin (int) funcion: la funcin a la que invocar cuando la interrupcin tiene lugar; esta funcin no debe tener parmetros ni devolver nada. Esta funcin es a veces referenciada como rutina de interrupcin de servicio modo define cuando la interrupcin debe ser disparada. Hay cuatro constantes predefinidas como valores vlidos:

LOW para disparar la interrupcin en cualquier momento que el pin se encuentre a valor bajo(LOW).

CHANGE para disparar la interrupcin en cualquier momento que el pin cambie de valor.

RISING para disparar la interrupcin cuando el pin pase de valor alto (HIGH) a bajo (LOW).

FALLING para cuando el pin cambie de valor alto (HIGH) a bajo (LOW)

Retorno: Ninguno Nota. Dentro de la funcin enlazada, la funcin delay() no funciona y el valor devuelto por la funcin millis() no se incrementar. Los datos serie recibidos en el transcurso de esta interrupcin pueden perderse. No deberas declarar como voltil cualquier variable que modifiques dentro de la funcin.

Usando las interrupciones Las interrupciones son tiles para hacer que las cosas sucedan automticamente en programas para microcontroladores, y puedan ayudar a resolver problemas de temporizacin. Una buena tarea en la que utilizar interrupciones podra ser leer un encoder rotacional, monitorizando la entrada del usuario. Si quisieras asegurarte de que un programa siempre captura los pulsos de un encoder rotacional, sin perder nunca un pulso, sera muy complicado escribir un programa que haga otra cosa, puesto que el programa debera estar constantemente consultando las lneas del sensor del encoder, de forma que capture los pulsos cuando tienen lugar. Otros sensores tienen un interfaz dinmico similar, como intentar leer un sensor de sonido que intenta capturar un click, o un sensor de ranuras por infrarrojos (fotointerruptor) tratando de capturar el paso de una moneda. En todas estas situaciones, usar una interrupcin, libera al microcontrolador de realizar otras tareas sin echar en falta el "timbre".

Ejemplo
int pin = 13; volatile int estado = LOW; void setup() { pinMode(pin, OUTPUT); attachInterrupt(0, parpadeo, CHANGE); } void loop() { digitalWrite(pin, estado); } void parpadeo() { estado = !estado; }

detachInterrupt(interrupt) Descripcin: Apaga la interrupcin dada. Parmetros: interrupt: el nmero de interrupcin a invalidar (0 o 1).

Interrupciones interrupts() Descripcin Activa las interrupciones (despus de haberlas desactivado con noInterrupts(). Las interrupciones permiten que se ejecuten ciertas tareas en segundo plano que estn activadas por defecto. Algunas funciones no funcionarn correctamente mientras las interrupciones estn desactivadas y la comunicacin entrante puede ser ignorada. Las interrupciones pueden perturbar ligeramente la temporizacin en el cdigo y deben ser desactivadas slo para partes particularmente crticas del cdigo.

Parmetros: Ninguno Devuelve: No devuelve nada Ejemplo

void setup() {} void loop() { noInterrupts(); // cdigo crtico y sensible al tiempo interrupts(); // otro cdigo }

noInterrupts() Descripcin Desactiva las interrupciones (pueden reactivarse usando interrupts()). Las interrupciones permiten que las operaciones importantes se realicen de forma transparente y estn activadas por defecto. Algunas funciones no funcionarn y los datos que se reciban sern ignorados mientras que las interrupciones estn desactivadas. Las interrupciones pueden perturbar ligeramente el tiempo de temporizado, sin embargo puede que sea necesario desactivarlas para alguna parte crtica del cdigo. Parmetros: Ninguno Devuelve: Nada

Ejemplo
void setup() {} void loop() { noInterrupts();

// Cdigo dependiente crticamente del tiempo interrupts(); // resto del cdigo aqu }

Comunicaciones Serial Se utiliza para la comunicacin entre la placa Arduino y un ordenador u otros dispositivos. Todas las placas Arduino tienen al menos un puerto serie (tambin conocido como UART o USART): Serial. Se comunica a travs de los pines digitales 0 (RX) y 1 (TX), as como con el ordenador mediante USB. Por lo tanto, si utilizas estas funciones, no puedes usar los pines 0 y 1 como entrada o salida digital. Puedes utilizar el monitor del puerto serie incorporado en el entorno Arduino para comunicarte con la placa Arduino. Haz clic en el botn del monitor de puerto serie en la barra de herramientas y selecciona la misma velocidad en baudios utilizada en la llamada a begin(). La placa Arduino Mega tiene tres puertos adicionales de serie: Serial1 en los pines 19 (RX) y 18 (TX), Serial2 en los pines 17 (RX) y 16 (TX), Serial3 en los pines 15 (RX) y 14 (TX). Para utilizar estos pines para comunicarse con el ordenador personal, necesitars un adaptador USB adicional a serie, ya que no estn conectados al adaptador USB-Serie de la placa Arduino Mega. Para usarlos para comunicarse con un dispositivo serie externo TTL, conecta el pin TX al pin RX del dispositivo, el RX al pin TX del dispositivo, y el GND de tu Arduino Mega a masa del dispositivo. (No conectes estos pines directamente a un puerto serie RS232, que operan a +/- 12V y esto puede daar la placa Arduino.)

begin() Descripcin Establece la velocidad de datos en bits por segundo (baudios) para la transmisin de datos en serie. Para comunicarse con el computador, utilice una de estas velocidades: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. Sin embargo, puedes especificar otras velocidades - por ejemplo, para comunicarte a travs de los pines 0 y 1 con un componente que requiere una velocidad de transmisin en particular. Sintaxis Serial.begin(speed) Solamente en Arduino Mega: Serial1.begin(speed) Serial2.begin(speed) Serial3.begin(speed) Parmetros. speed: Velocidad en bits por segundo (baudios) - long Devuelve: nada Ejemplo:
void setup() { Serial.begin(9600); velocidad en 9600 bps } void loop() {}

//

abre

el

puerto

serie

establece

la

Ejemplo para Arduino Mega:

// Arduino Mega usando sus 4 puertos serie // (Serial, Serial1, Serial2, Serial3), // con diferentes velocidades de datos: void setup(){ Serial.begin(9600);

Serial1.begin(38400); Serial2.begin(19200); Serial3.begin(4800); Serial.println("Hola ordenador"); Serial1.println("Hola Serial 1"); Serial2.println("Hola Serial 2"); Serial3.println("Hola Serial 3"); } void loop() {}

end() Descripcin Desactiva la comunicacin serie, permitiendo a los pines RX and TX ser usados como entradas o salidas digitales. Para reactivar la comunicacin serie, llama al mtodo Serial.begin(). Sintaxis Serial.end() Solamente en Arduino Mega: Serial1.end() Serial2.end() Serial3.end() Parmetros: ninguno Devuelve: nada

available() Descripcin Devuelve el nmero de bytes (caracteres) disponibles para ser leidos por el puerto serie. Se refiere a datos ya recibidos y disponibles en el buffer de recepcin del puerto (que tiene una capacidad de 128 bytes). Sintaxis Serial.available() Slo para Arduino Mega: Serial1.available() Serial2.available() Serial3.available() Parametros: ninguno Devuelve: el nmero de bytes disponibles para ser ledos Ejemplo
int incomingByte = 0; // para los datos de entrada serie // abre el puerto serie, establece la

void setup() { Serial.begin(9600); velocidad a 9600 bps } void loop() {

// enva datos solo cuando recibe datos: if (Serial.available() > 0) { // lee el byte de entrada: incomingByte = Serial.read(); // muestra lo que tiene: Serial.print("He recibido: "); Serial.println(incomingByte, DEC); } }

Ejemplo Arduino Mega:

void setup() { Serial.begin(9600); Serial1.begin(9600); } void loop() { // lee desde el puerto 0, enva al puerto 1: if (Serial.available()) { int inByte = Serial.read(); Serial1.print(inByte, BYTE); } // lee del puerto 1, enva al puerto 0: if (Serial1.available()) { int inByte = Serial1.read(); Serial.print(inByte, BYTE); } }

read() Descripcin: Lee los datos entrantes del puerto serie. Sintaxis Serial.read() Solamente en Arduino Mega: Serial1.read() Serial2.read() Serial3.read() Parmetros: Ninguno Devuelve: el primer byte disponible recibido por el puerto serie (devuelve -1 si no hay datos disponibles) - int

Ejemplo
int incomingByte = 0; // para el byte leido // abre el puerto serie a 9600 bps

void setup() { Serial.begin(9600); } void loop() {

// envia datos solamente cuando recibe datos if (Serial.available() > 0) { // lee el byte entrante: incomingByte = Serial.read(); // dice lo que ha recibido: Serial.print("He recibido: "); Serial.println(incomingByte, DEC); } }

flush() Descripcin Vaca el bfer de entrada de datos en serie. Es decir, cualquier llamada a Serial.read () o Serial.available () devolver slo los datos recibidos despus la llamada ms reciente a Serial.flush (). Sintaxis Serial.flush() Solamente en Arduino Mega: Serial1.flush() Serial2.flush() Serial3.flush() Parmetros: ninguno Retorna: nada

print() Descripcin Imprime los datos al puerto serie como texto ASCII. Este comando puede tomar muchas formas. Los nmeros son impresos mediante un juego de caracteres ASCII para cada dgito. Los valores de tipo "float" son impresos en forma de dgitos ASCII con dos decimales por defecto. Los valores tipo "byte" se envan como un nico carcter. Los caracteres y las cadenas se envan tal cual. Por ejemplo:

Serial.print(78) imprime "78" Serial.print(1.23456) imprime "1.23" Serial.print(byte(78)) imprime "N" (cuyo cdigo ASCII es 78) Serial.print('N') imprime "N" Serial.print("Hello world.") imprime "Hello world."

Un segundo parmetro opcional especifica la base (formato) a usar; los valores permitidos son BYTE, BIN (binarios o base 2), OCT (octales o base 8), DEC (decimales o base 10), HEX (hexadecimales o base 16). Para nmeros de coma flotante, este parmetro especifica el numero de posiciones decimales a usar. Por ejemplo:

Serial.print(78, BYTE) imprime "N" Serial.print(78, BIN) imprime "1001110" Serial.print(78, OCT) imprime "116" Serial.print(78, DEC) imprime "78" Serial.print(78, HEX) imprime "4E" Serial.println(1.23456, 0) imprime "1" Serial.println(1.23456, 2) imprime "1.23" Serial.println(1.23456, 4) imprime "1.2346"

Sintaxis Serial.print(val) Serial.print(val, format) Parmetros: val: el valor a imprimir - de cualquier tipo format: especifica el nmero de la base (para nmeros enteros) o el nmero de posiciones decimales (para nmeros de coma flotante o tipo "float") Devuelve: Nada Ejemplo:
/* Usa un bucle FOR para los datos e imprime un nmero en varios formatos. */ int x = 0; // variable void setup() { Serial.begin(9600); } // abre el puerto serie a 9600 bps:

void loop() { // print labels Serial.print("SIN FORMATO"); Serial.print("\t"); Serial.print("DEC"); Serial.print("\t"); Serial.print("HEX"); Serial.print("\t"); Serial.print("OCT"); Serial.print("\t"); Serial.print("BIN"); Serial.print("\t"); Serial.println("BYTE"); for(x=0; x< 64; x++){

// imprime un texto // imprime un tabulado

// solo una parte de la tabla

// imprime en varios formatos: Serial.print(x); // imprime como codificado ASCII decimal igual que "DEC"

Serial.print("\t"); Serial.print(x, DEC); Serial.print("\t"); Serial.print(x, HEX); Serial.print("\t"); Serial.print(x, OCT); Serial.print("\t"); Serial.print(x, BIN); Serial.print("\t");

// imprime un tabulado // imprime como codificado ASCII decimal // imprime un tabulado // imprime como codificado ASCII hexadecimal // imprime un tabulado // imprime como codificado ASCII octal // imprime un tabulado // imprime como codificado ASCII binario // imprime un tabulado

Serial.println(x, BYTE); // imprime el valor en bruto del byte, // y aade el salto de linea con "println" delay(200); // espera 200 milisegundos } Serial.println(""); //imprime otro salto de linea }

Sugerencias de programacin / Problemas conocidos El ltimo carcter a imprimir se transmite a travs del puerto serie despus de que Serial.print () ha regresado.

println() Descripcin Imprime los datos al puerto serie como texto ASCII seguido de un retorno de carro (ASCII 13, o '\r') y un carcter de avance de lnea (ASCII 10, o '\n'). Este comando tiene la misma forma que Serial.print (). Sintaxis Serial.println(val) Serial.println(val, format)

Prarmetros val: el valor a imprimir - de cualquier tipo format: especifica el nmero de la base (para nmeros enteros) o el nmero de posiciones decimales (para nmeros de coma flotante o tipo "float") Devuelve: Nada Example:
/* Analog input Lee el pin analgico 0, e imprime su valor por el puerto serie. */ int analogValue = 0; // variable para guardar el valor analogico

void setup() { // abre el puerto serie a 9600 bps: Serial.begin(9600); } void loop() { // lee la entrada analogica en el pin 0: analogValue = analogRead(0); // imprime el valor en varios formatos: Serial.println(analogValue); // imprime Serial.println(analogValue, DEC); // imprime Serial.println(analogValue, HEX); // imprime Serial.println(analogValue, OCT); // imprime Serial.println(analogValue, BIN); // imprime Serial.println(analogValue, BYTE); // imprime como ASCII decimal como ASCII decimal como ASCII hexadecimal como ASCII octal como ASCII binario el valor del byte

// espera 10 milisegundos antes de la siguiente lectura. delay(10); }

write() Descripcin Escribe datos binarios en el puerto serie. Estos datos se envan como un byte o una serie de bytes; para enviar los caracteres que representan los dgitos de un nmero usar funcion print () en su lugar. Syntax Serial.write(val) Serial.write(str) Serial.write(buf, len) Arduino Mega tambien soporta: Serial1, Serial2, Serial3 (en lugar de Serial) Parmetros val: un valor para enviar como un solo byte str: una cadena 'string' para enviar como una serie de bytes buf: un 'array' para enviar como una serie de bytes len: longitud del bfer