Programacin del ARDUINO Recopilacin de WEB por Ing. Armando Mtz. R.Entorno de desarrollo

Para programar la placa es necesario descargarse de la pgina web de Arduino el entorno de desarrollo (IDE). Se dispone de versiones para Windows y para MAC, as como las fuentes para compilarlas en LINUX. En la Figura 2 se muestra el aspecto del entorno de programacin. En el caso de disponer de una placa USB es necesario instalar los drivers FTDI. Estos drivers vienen incluidos en el paquete de Arduino mencionado anteriormente. Existen en la web versiones para distintos sistemas operativos.

Figura 2. Entorno de desarrollo.Lo primero que tenemos que hacer para comenzar a trabajar con el entorno de desarrollo de arduino es configurar las comunicaciones entre la placa Arduino y el PC. Para ello deberemos abrir en el men "Tools"la opcin "Serial Port". En esta opcin deberemos seleccionar el puerto serie al que est conectada nuestra placa. En Windows, si desconocemos el puerto al que est conectado nuestra placa podemos descubrirlo a travs del Administrador de dispositivos (Puertos COM & LPT/ USB Serial Port).

El primer paso para comprobar que todo lo que hemos hecho hasta ahora est bien y familiarizarnos con el interfaz de desarrollo, es abrir uno de los ejemplos. Se recomienda abrir el ejemplo "Blink". Para ello debemos acceder a travs del men File ( Sketchbook ( Examples ( Digital ( Blink.

El ejemplo "Blink" lo nico que hace es parpadear un LED que est colocado en el pin nmero 13 de la placa. Vamos a ver qu hay que hacer para subir el programa a la placa Arduino. Primero comprobamos que el cdigo fuente es el correcto. Para ello pulsamos el botn de verificacin de cdigo que tiene forma de tringulo inclinado 90 grados (Figura 3.a). Si todo va bien deber aparecer un mensaje en la parte inferior de la interfaz indicando "Done compiling". Una vez que el cdigo ha sido verificado procederemos a cargarlo en la placa. Para ello tenemos que pulsar el botn de reset de la placa (Figura 3.b) e inmediatamente despus pulsar el botn que comienza la carga (Figura 3.c).

Durante la carga del programa, en la placa USB, se encendern los LED que indican que se estn enviando y recibiendo informacin por el puerto serie: TX/RX. Si todo se ha realizado correctamente debe aparecer el mensaje "Done uploading". Ahora tan slo queda esperar unos 8 segundos aproximadamente para comprobar que todo ha salido bien. Si el led colocado en el pin 13 de la placa se enciende y se apaga cada segundo entonces todo ha ido bien. Por fin tenemos todo listo para empezar a trabajar con la placa Arduino.

Figura 3. a) Compilar programa. b) Botn de reset. c) Transferir programa a la placa.Estructura bsica de un programa

La estructura bsica de programacin de Arduino es bastante simple y divide la ejecucin en dos partes: setup y loop. Setup() constituye la preparacin del programa y loop() es la ejecucin. En la funcin Setup() se incluye la declaracin de variables y se trata de la primera funcin que se ejecuta en el programa. Esta funcin se ejecuta una nica vez y es empleada para configurar el pinMode (p. ej. si un determinado pin digital es de entrada o salida) e inicializar la comunicacin serie. La funcin loop() incluye el cdigo a ser ejecutado continuamente (leyendo las entradas de la placa, salidas, etc.).

void setup() {

inMode(pin, OUTPUT); // Establece 'pin' como salida

}

void loop() {

digitalWrite(pin, HIGH);// Activa 'pin'

delay(1000);

// Pausa un segundo

digitalWrite(pin, LOW); // Desactiva 'pin'

delay(1000);

}

Como se observa en este bloque de cdigo cada instruccin acaba con ; y los comentarios se indican con //. Al igual que en C se pueden introducir bloques de comentarios con /* ... */.

Funciones

Una funcin es un bloque de cdigo identificado por un nombre y que es ejecutado cuando la funcin es llamada. La declaracin de una funcin incluye en primer lugar el tipo de datos que devuelve la funcin (e.j. int si lo que devuelve es un valor entero). Despus del tipo de datos se especifica el nombre de la funciOLE_LINK1int delayVal() {

int v;

// crea una variable temporal 'v'

v = analogRead(pot); // lee el valor del potencimetro

v /= 4;

// convierte los valores 0-1023 a 0-255

return v;

// devuelve el valor final de la variable

}

Variables

Una variable debe ser declarada y opcionalmente asignada a un determinado valor. En la declaracin de la variable se indica el tipo de datos que almacenar (int, float, long)

int inputVariable = 0;

Una variable puede ser declarada en el inicio del programa antes de setup(), localmente a una determinada funcin e incluso dentro de un bloque como pueda ser un bucle. El sitio en el que la variable es declarada determina el mbito de la misma. Una variable global es aquella que puede ser empleada en cualquier funcin del programa. Estas variables deben ser declaradas al inicio del programa (antes de la funcin setup()).

int v;

// 'v' es visible en todo el programa

void setup() {

// no se requiere setup

}

void loop() {

for (int i=0; i y, x = y.

Y los siguientes operadores lgicos:

Y lgico: if (x > 0 && x < 5). Cierto si las dos expresiones lo son.

O lgico: if (x > 0 || y > 0). Cierto si alguna expresin lo es.

NO lgico: if (!x > 0). Cierto si la expresin es falsa.

El lenguaje de Arduino presenta las siguientes constantes predefinidas:

TRUE / FALSE.

HIGH/LOW. Estas constantes definen los niveles de los pines como HIGH o LOW y son empleados cuando se leen o escriben en las entradas o salidas digitales. HIGH se define como el nivel lgico 1 (ON) o 5 V. LOW es el nivel lgico 0, OFF, o 0 V.

INPUT/OUTPUT. Constantes empleadas con la funcin pinMode() para definir el tipo de un pin digital usado como entrada INPUT o salida OUTPUT. Ej. pinMode(13, OUTPUT);

Sentencias condicionales

El lenguaje de arduino permite realizar sentencias condicionales if, if... else, for, while, do... while. Su utilizacin es similar a las funciones correspondientes en C.

Entradas y salidas digitales y analgicas

9.1. Funcin pinMode(pin, mode)Funcin usada en la function setup() para configurar un pin dado para comportarse como INPUT o OUTPUT. Ej. pinMode(pin, OUTPUT); configura el pin nmero 'pin' como de salida. Los pines de Arduino funcionan por defecto como entradas, de forma que no necesitan declararse explcitamente como entradas empleando pinMode().

9.2. Funcin digitalRead(pin)Lee el valor desde un pin digital especfico. Devuelve un valor HIGH o LOW. El pin puede ser especificado con una variable o una constante (0-13). Ej. v = digitalRead(Pin);

9.3. Funcion digitalWrite(pin, value)Introduce un nivel alto (HIGH) o bajo (LOW) en el pin digital especificado. De nuevo, el pin puede ser especificado con una variable o una constante 0-13. Ej. digitalWrite(pin, HIGH);

9.4. Funcin analogRead(pin)Lee el valor desde el pin analgico especificado con una resolucin de 10 bits. Esta funcin solo funciona en los pines analgicos (0-5). El valor resultante es un entero de 0 a 1023. Los pines analgicos, a diferencia de los digitales no necesitan declararse previamente como INPUT o OUTPUT.

9.5. Funcin analogWrite(pin, value)Escribe un valor pseudo-analgico usando modulacin por ancho de pulso (PWM) en un pin de salida marcado como PWM. Esta funcin est activa para los pines 3, 5, 6, 9, 10, 11. Ej analogWrite(pin, v); // escribe 'v' en el 'pin' analgico. Puede especificarse un valor de 0 - 255. Un valor 0 genera 0 V en el pin especificado y 255 genera 5 V. Para valores de 0 a 255, el pin alterna rpidamente entre 0 V y 5 V, cuanto mayor sea el valor, ms a menudo el pin se encuentra en HIGH (5 V). Por ejemplo, un valor de 64 ser 0 V tres cuartas partes del tiempo y 5 V una cuarta parte. Un valor de 128 ser 0 V la mitad del tiempo y 5 V la otra mitad. Un valor de 192 ser 0 V una cuarta parte del tiempo y 5 V tres cuartas partes.

Funciones de tiempo y matemticas

delay(ms). Realiza una pausa en el programa la cantidad de tiempo en milisegundos especificada en el parmetro (mximo 1000, mnimo 1).

millis(). Devuelve la cantidad de milisegundos que lleva la placa Arduino ejecutando el programa actual como un valor long unsigned. Despus de de 9 horas el contador vuelve a 0.

min(x,y). max(x,y). Devuelve el mnimo y el mximo respectivamente de entre sus parmetros.

Funciones de generacin aleatoria

randomSeed(seed). Especifica un valor o semilla como el punto de inicio para la funcin random(). Este parmetro debe ser realmente aleatorio y para ello puede emplearse la funcin millis() o incluso analogRead() para leer ruido elctrico desde una entrada analgica.

random(max), random(min, max). Esta funcin devuelve un valor aleatorio entre el rango especificado.

Puerto serie

Serial.begin(rate). Abre un Puerto serie y especifica la velocidad de transmisin. La velocidad tpica para comunicacin con el ordenador es de 9600 aunque se pueden soportar otras velocidades.

Serial.println(data). Imprime datos al puerto serie seguido por un retorno de lnea automtico. Este comando tiene la misma forma que Serial.print() pero este ltimo sin el salto de lnea al final. Este comando puede emplearse para realizar la depuracin de programas. Para ello puede mandarse mensajes de depuracin y valores de variables por el puerto serie. Posteriormente, desde el entorno de programacin de Arduino, activando el "Serial Monitor" se puede observar el contenido del puerto serie, y, por lo tanto, los mensajes de depuracin. Para observar correctamente el contenido del puerto serie se debe tener en cuenta que el "Serial Monitor" y el puerto serie han de estar configurados a la misma velocidad (Para configurar la velocidad del puerto serie se har con el comando Serial.begin(rate)).

Serial.read().Lee o captura un byte (un caracter) desde el puerto serie. Devuelve -1 si no hay ningn carcter en el puerto serie.

Serial.available(). Devuelve el nmero de caracteres disponibles para leer desde el puerto serie.

Ejemplos de cdigo

Salida digital En este ejemplo el LED conectado al pin 13 parpadea cada segundo.

int ledPin = 13;

// LED que se encuentra en el pin 13

void setup(){

pinMode(ledPin, OUTPUT);// El p1n 13 ser una salida digital

}

void loop(){

digitalWrite(ledPin, HIGH);// Enciende el LED

delay(1000);

// Pausa de 1 segundo

digitalWrite(ledPin, LOW); // Apaga el LED

delay(1000);

// Pausa de 1 segundo

}

Salida digital II En este ejemplo el LED conectado al pin 13 parpadea en un intervalo de tiempo variable que depende del nmero de veces que se ejecuta el programa (funcinloop)

int ledPin = 13;// LED que se encuentra en el pin 13

int n = 0; //Entero que contar el paso por la funcin loop

void setup(){

pinMode(ledPin, OUTPUT);// El p1n 13 ser una salida digital

}

void loop(){

digitalWrite(ledPin, HIGH);// Enciende el LED

delay(1000);

// Pausa de 1 segundo

digitalWrite(ledPin, LOW);

// Apaga el LED

n++;

//Incrementamos n

delay(delayVal(n));

//Pausa de un tiempo variable

}

//Funcin que devuelve un valor tipo entero segn el parmetro pasado

int delayVal(int f){

return f*100;

}

Entrada digital Este ejemplo lee el valor de un interruptor conectado en el pin 2. Cuando el interruptor est cerrado en el pin de entrada habr un estado alto (HIGH) y se encender el LED.

int ledPin = 13; // Pin de salida para el LED

int inPin = 2; // Pin de entrada (donde est conectado el interruptor)

void setup() {

pinMode(ledPin, OUTPUT);

pinMode(inPin, INPUT);

}

void loop() {

if (digitalRead(inPin) == HIGH){// Si se activa interruptor

digitalWrite(ledPin, HIGH);// Enciende el LED

delay(1000);

// Pause de 1 segundo

digitalWrite(ledPin, LOW); // Apaga el LED

delay(1000);

// Pausa de 1 segundo

}

}

Salida PWM Modulacin por ancho de pulso (PWM) puede emplearse, por ejemplo, para establecer el brillo de un led o controlar un servomotor. En el siguiente ejemplo se va aumentando y decrementando el brillo del pin 9 mediante PWM.

int ledPin = 9;

// Pin controlado por PWM

void setup(){}

void loop() {

for (int i=0; i=0; i--) {

analogWrite(ledPin, i);

delay(100);

}

}

Entrada a partir de un potencimetro En el siguiente cdigo se emplea arduino para controlar la frecuencia de parpadeo de un LED.

int potPin = 0;

// Pin de entrada para el potencimetro

int ledPin = 13;

// Pin de salida para el LED

void setup() {

pinMode(ledPin, OUTPUT); // Declara el pin del LED como de salida

}

void loop() {

digitalWrite(ledPin, HIGH);// Enciende el LED

delay(analogRead(potPin));

// Lee el valor del potencimetro

digitalWrite(ledPin, LOW);

// Apaga el LED

delay(analogRead(potPin));

}

Estructura de un Sketch.

Llegados a ese punto debemos hacer un pequeo alto y explicar algunas cosas referentes a un Sketch (programa de Arduino).

El lenguaje con el que se programan nuestras Arduinos es un derivado del lenguaje de programacinWiring. Su estructura y su sintaxis es igual que la de C, por eso suelo bromear diciendo que todo el que sepa programar en C sabe programar una Arduino. De hecho todas las libreras de C y algunas de C++ se pueden utilizar con Arduino.

La estructura bsica de un sketch es muy similar a la de cualquier programa en C con algunas diferencias impuestas por el hecho de que nuestra plataforma interacta directamente con el medio fsico que le rodea.

As la primera parte de un Sketch ser la declaracin de variables, donde definiremos las variables globales del Sketch declarando su tipo y, si queremos, su valor inicial. Estas variables sern accesibles desde cualquier parte de nuestro Sketch al contrario que las variables locales, que son las que se declaran dentro de una funcin o dentro de una estructura de control (por ejemplo un bucle For).

Ejemplos:

123intpin;// crea la variable de tipo entero pinintnumero=1;// crea la variable de tipo entero nmero y le asigna el// valor 1

Los tipos de variables los veremos en profundidad ms adelante.

La segunda parte de un Sketch es una parte que solo se ejecuta una vez tras el arranque de la placa Arduino, el Setup.

123456Void Setup(){.........}

Suele utilizarse para definir los pines que vamos a utilizar y declararlos como entradas o como salidas, sobre todo en los ejemplos que encontraremos en la web y en los ejercicios que haremos en este curso, y esto suele inducirnos a algunos errores como creer que un pin solo se puede utilizar como entrada o como salida en un sketch, lo cual no es cierto, se puede cambiar durante la ejecucin del Sketch.

El Setup () debe considerarse como lo que es: un conjunto de cdigo que solo se ejecuta una vez cuando Arduino arranca. Esto nos dar una increble flexibilidad a la hora de programar.

Siguiente parte importante de un Sketch: el Loop. Es la parte principal de nuestro programa pues en el tendremos que poner el cdigo para que el microcontrolador lo ejecute de manera recursiva, es decir, esta parte del Sketch se repetir una y otra vez mientras la placa Arduino tenga energa.

123456Void Loop(){.........}

No todo el cdigo tiene que estar en el Loop, ciertas partes pueden ser escritas fuera de este bucle: las funciones. Las funciones son fragmentos de cdigo separado al que se puede llamar desde el Setup o desde el Loop, pero eso lo veremos ms adelante.

Los Sketches generados desde el Arduino IDE se guardan en archivos con la extensin .pde, esto es as porque el Arduino IDE es una adaptacin del IDE de Processing (del cual viene tambin el nombre Sketch). De echo pde viene de Processing Development Envoironment.

Ejercicio 2: Blink without delay.

En el ejercicio anterior vimos el ejemplo de Sketch ms sencillo que se puede hacer con Arduino, que unLEDparpadee controlando los intervalos de tiempo con la funcin delay().

La funcin delay() es un retardo, la placaArduino UNOno hace otra cosa que contar los milisegundos que le especifiquemos entre los parntesis. En un Sketch sencillo como el del ejercicio 1 no hay problema en tener al microcontrolador ocupado en la tarea de contar milisegundos, pero en general sern pocas las veces que podamos permitirnos ese lujo. Lo ms normal ser que adems de controlar el tiempo nuestra Arduino tenga que ocuparse de otras tareas.

Por ese motivo vamos a ver cmo puede Arduino controlar el tiempo que est encendido el LEDsin recurrir a la funcin delay() y mientras tanto queda el microcontrolador libre para hacer otras cosas.El ejercicio 2: Blink WithOut Delay, que figura entre los ejemplos que vienen con el IDE de Arduino utiliza la funcin millis() para controlar el tiempo. Esta funcin devuelve el nmero de milisegundos que han transcurrido desde que se ha encendido por ltima vez. Explicar la funcin millis() con ms detalle en el apndice del ejercicio 2.

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758/* Parpadeo sin delay()Enciende y apaga un LED conectado a un pin digital sin utilizar la funcin delay(). Esto significa que otro cdigo se puede ejecutar al mismo tiempo sin ser interrumpido por el cdigo que controla el parpadeo del LEDCircuito: Un LED conectado entre el pin 13 y el pin GND.Nota: en muchos Arduinos hay un LED en la placa conectado al pin 13, por lo que no sera necesario un LED externo para este ejemplo.Creado en 2005 por David A. Mellis, modificado el 8/2/2010 por Paul Stoffregen.Este ejemplo es de dominio pblico*/

// las constantes no cambian. Las usamos aqu para establecer los nmeros de los pines.intledPin=13;// el nmero del pin conectado al LED

// variables que cambiarn de valor.intledState=LOW;// ledState se usar para establecer el estado del LED

longpreviousMillis=0;// almacenar la ltima vez que el estado del LED//se actualiz

// la siguiente variable es del tipo long por que el tiempo medido en// milisegundos supera rpidamente al nmero que puede ser almacenado en una// variable del tipo intlonginterval=1000;// intervalo del parpadeo (en milisegundos)

voidsetup(){// establece el pin digital como salida:pinMode(ledPin,OUTPUT);}

voidloop(){// Aqu es donde pondramos el cdigo que debe ejecutarse durante todo el// tiempo.

// Se comprobar si es el momento de parpadear el LED, esto es, si la// diferencia entre el tiempo transcurrido y el tiempo en que parpade// por ltima vez el LED es mayor que el intervalo que establecimos en// la declaracin de variables.

unsignedlongcurrentMillis=millis();// Se toma el tiempo actual

// se comprueba si el tiempo actual menos el tiempo en que el LED cambi// de estado por ltima vez es mayor que el intervalo.if(currentMillis-previousMillis>interval){

// Si se cumple la condicin se guarda el nuevo tiempo// en el que el LED cambia de estadopreviousMillis=currentMillis;

// Y ahora cambiamos de estado el LED, si est encendido a// apagado o viceversa.if(ledState==LOW)ledState=HIGH;elseledState=LOW;

// Hacemos que el contenido de la variable llegue al LEDdigitalWrite(ledPin,ledState);}}

Este ejercicio est basado en los ejemplos de la pgina oficial:http://arduino.cc/en/Tutorial/BlinkWithoutDelayhttp://arduino.cc/es/Tutorial/BlinkWithoutDelayEjercicio 2:A estas alturas somos unos expertos en el arte de hacer que unLEDse encienda o se apague, hemos visto la estructura de un Sketch y hemos utilizado los comandos ms usuales en los ejemplos de programacin de Arduino.

En este apndice repasaremos los comandos vistos hasta ahora, su funcin, su sintaxis y disiparemos algunas dudas sobre ellos.

Como ya hemos visto la estructura de un Sketch es la misma que la de un programa en C y el lenguaje de programacin de Arduino, Wired, es un derivado de C, sin embargo las particularidades de Arduino hacen que Wired tenga unos comandos muy especficos que la gente que ha programado en C no ha visto nunca.

Arduinono utiliza como entrada un teclado y como salida una pantalla (la configuracin ms habitual en ordenadores), si no que se conecta directamente a su entorno fsico o a perifricos que sern los que interactuarn con el entorno fsico. Arduino es un ordenador que enciende y apaga luces, mueve cosas, mide temperaturas, presiones, emite sonidos y se comunica con otros dispositivos. Estas capacidades requieren que los comandos con los que es programado sean especficos para estas tareas de la misma forma que el C de consola tiene comandos especficos para leer datos de un teclado y mostrar resultados por pantalla.

Empecemos:

1pinMode(nmero-de-pin,modo);

El comando pinMode() sirve para establecer a cada pin de entrada o salida digital que vayamos a utilizar el modo en el que lo haremos, es decir, declararemos un pin identificado por su nmero como entrada o como salida.

El nmero del pin se puede introducir tal cual est serigrafiado en la placa (del 0 al 13) , pero es muy recomendable introducirlo como una variable, constante o definicin con el valor introducido previamente en la parte del Sketch en la que se hace la definicin de variables. Esto nos permitir cambiar su valor sin tener que repasar todo el cdigo para cambiar el nmero de pin de forma manual y en las ocasiones en las que trabajamos con cables y, por la razn que sea, los queremos cambiar de pin resulta sumamente prctico.

Como modo pondremos OUTPUT o INPUT dependiendo de si queremos que el pin sea una salida o una entrada digital. En maysculas, recordemos que en este lenguaje se hace distincin entre maysculas y minsculas, si escribimos una palabra mal el compilador nos dar un error.

Declararemos solo los pines que vayamos a utilizar, no tiene sentido declarar pines a los que no vamos a conectar a nada. Qu pasa con los pines que no declaramos? por definicin Arduino trata a todos los pines como entradas a menos que especifiquemos lo contrario, esto significa que los pines que vayamos a utilizar como entradas no sera necesario declararlos con el comando pinMode(), solo los que vayamos a utilizar como salidas. Pero esto ltimo no es nada recomendable, de hecho casi sera mejor que no lo hubiera dicho.

No cuesta nada declarar cada pin que utilice el Sketch como entrada o salida en el setup() y si lo documentamos correctamente ganamos en claridad y limpieza. Esto es especialmente til si vamos a publicar nuestro Sketch o si lo vamos a tener que volver a editar en el futuro.

12pinMode(pulsador,INPUT);// declara el pin al que est conectado el//pulsador como entrada

Este ejemplo es perfectamente comprensible para todo el que lo lee hoy y dentro de seis meses, si no lo hacemos as y suponemos que un pin est conectado a un pulsador y trabajamos con el directamente ser difcil de entender por otra persona en unos meses incomprensible incluso para nosotros.

1digitalWrite(nmero-de-pin,estado);

El comando digitalWrite() sirve para establecer la salida digital en el pin que establezcamos. Para el parmetro del nmero de pin digital sirve todo lo dicho en la explicacin del comando pinMode(), mejor desde una variable, constante o definicin y por los mismos motivos.

Este comando slo admite dos estados HIGH o LOW, alto o bajo y que se corresponden con un 1 un 0. De hecho podramos introducir el comando de las siguientes formas:

123digitalWrite(pin,HIGH);// la forma correcta de hacerlodigitalWrite(pin,1);// no es nada conveniente hacerlo asdigitalWrite(pin,estado);// donde estado es una variable

En el ltimo caso la variable de nombreestado, declarada en la cabecera del Sketch, puede ser del tipo entero (int) y contener un 0 o un 1 o asignarle los valores HIGH o LOW. Incluso puede ser una variable de tipo boolean y contener un TRUE equivalente a un HIGH o un FALSE que equivaldra a un LOW. Como se puede ver tenemos unas posibilidades inmensas para trabajar con las salidas de forma matemtica, aunque eso lo dejaremos para ms adelante.

De momento usaremos siempre HIGH o LOW o estos mismos valores contenidos en una variable del tipo entero (int) para que nuestro cdigo sea limpio y comprensible.

Elctricamente un nivel HIGH corresponde a +5v en la salida del pin y el nivel LOW a 0v, con una pequea tolerancia, por lo que las medidas con el multmetro entre el pin y GND pueden oscilar entre 49v y 51v para HIGH y 0v y 01v para LOW.Los modelos de Arduino que trabajan a 33v tienen esta misma salida para el nivel HIGH.

1delay(nmero);

El comando delay() detiene la ejecucin del Sketch durante el tiempo que le especifiquemos expresado en milisegundos.

Generalmente utilizaremos este comando de forma muy limitada precisamente por esa caracterstica suya de detener completamente la ejecucin del Sketch. Es til en algunos procesos de comunicacin para darle tiempo a un perifrico a que procese la informacin que le mandamos y nos devuelva un resultado o para impedir rebotes en la lectura de sensores, y en estos casos el intervalo de tiempo lo introduciremos de forma directa como un nmero.

Si necesitamos pasarle al comando delay() el tiempo dentro de una variable hay que tener en cuenta que esta debe ser del tipounsigned long, es decir, un nmero de 32 bits sin signo (veremos lo que esto significa en el siguiente comando).

1millis();

El comando millis() nos devuelve el nmero de milisegundos que han transcurrido desde la ltima vez que Arduino se puso en funcionamiento y el momento en el que se ejecuta este comando.

El valor que nos devuelve es del tipounsigned long, un nmero entero sin signo de 32 bits cuyo valor puede ser de 0 a 4,294,967,295. Cuando el temporizador interno de Arduino supera ese valor mximo vuelve a empezar desde 0, esto hay que tenerlo en cuenta en los sistemas conectados permanentemente y que hacen uso de este comando, pues el valor de retorno de millis() desborda cada 50 das.

El comando millis() no acepta parmetros dentro del parntesis, si intentamos darle alguno el compilador nos devolver un error. Sin embargo forma parte de su sintaxis y, aunque vaco, no debemos olvidar nunca los parntesis.

Y con esto terminamos algo de teora por ahora, vamos a hacer cosas ms interesantes: para el prximo ejercicio necesitaremos unservoy unpotencimetro de 10KOhms.

Ejercicio 3: servos

Vamos a empezar a hacer ejercicios con un nivel de dificultad algo mayor y vamos a empezar a utilizar la protoboard para ir pinchando en ella algunos componentes y cables para hacer conexiones.

Primero haremos un mando para unservode radio control.Utilizaremos un potencimetro para controlar el movimiento de giro del eje de un servomotor.Circuito:

Los servomotores tienes tres cables: alimentacin (rojo), GND (que puede ser negro o marrn) y seal (que puede ser blanco o naranja). El cable de alimentacin debe ser conectado al pin 5V de la placa Arduino. El cable GND debe ser conectado al pin GND de la placa Arduino. El pin de seal se conecta al pin 9 de la placaArduino UNOpara este ejercicio.

AVISO: En este ejercicio vamos a utilizar un micro servo de 9g cuyo consumo es tolerado por la placa, para otros montajes en los que el servo utilizado sea mayor NO se pueden conectar la tierra y la alimentacin del servo a la placa Arduino si no directamente a la fuente de alimentacin o a una batera.El potencimetro debe ser conectado de manera que los dos pines exteriores estn conectado a alimentacin (+5V) y a GND, el pin central lo conectaremos a la entrada analgica 0 en elArduino UNO.

En este ejercicio vamos a ver como se incluye una librera para hacernos ms fcil el interactuar con un dispositivo, en este caso el servo.

Cdigo:

123456789101112131415161718192021222324// Controlando la posicin de un servo usando un potencimetro (resistencia variable)// Por Michal Rinott

#include // Carga la librera Servo.h que contiene mtodos para trabajar con servos

Servomyservo;// Crea un objeto servo para controlar el servomotorintpotpin=0;// Pin analgico usado para conectar el potencimetrointval; // variable para leer el valor del pin analgico

voidsetup(){myservo.attach(9);// asocia el servo al pin 9}

voidloop(){val=analogRead(potpin);// lee el valor del potencimetro (valor //entre 0 y 1023)val=map(val,0,1023,0,179);// escala el valor para usarlo con el //servo (valor entre 0 y 180)myservo.write(val); // fija la posicin del servo de acuerdo //al valor escaladodelay(15); // espera a que el servo se posicione}

Con un cdigo tan sencillo haremos que el servo se mueva segn movamos el potencimetro de modo que al estar el potencimetro en el lmite inferior de su recorrido el servo estar en la posicin de 0, si centramos el potencimetro el servo estar en la posicin de 90 y si llevamos el potencimetro a su lmite superior el servo alcanzar la posicin de 180.

Vamos a aprovechar este ejercicio para introducir un mtodo que puede ser utilizado tanto para el de depurado de cdigo como el calibrado de un actuador o un sensor.

Imaginemos que tenemos hecho nuestro Sketch, lo subimos a la placa y, a pesar de estar correctamente escrito (no da errores el compilador), no hace lo que nosotros queremos. El error puede estar en la forma en que trabajamos con los valores de forma interna y eso no lo podemos ver a menos que los mostremos por el monitor serie.

Otro caso puede ser que, una vez realizado nuestro montaje, queramos que el servo comience su recorrido desde una posicin determinada y no sabemos cul es. Entonces podemos utilizar el monitor serie para calibrar nuestro servo y su recorrido.

Para ello activaremos el puerto serie incluyendo en elsetup() la lnea:

1Serial.begin(9600);

Esta instruccin inicializar la comunicacin con el ordenador a travs del puerto serie.

Luego iremos al final del Sketch, justo a la ltima lnea, donde est el comando delay(15) y antes de ella insertaremos el comando que dar salida a los datos que veremos en el monitor serie:

1Serial.println(val);

Por ltimo, y para darle tiempo al monitor serie a mostrar los datos sin que estos bailen a toda velocidad cambiaremos el valor del comando delay() a 500ms. De esta forma nuestro Sketch mover el servo y nos mostrar la posicin en la que se encuentra cada medio segundo, as podemos dejar el servo en la posicin exacta que queramos viendo el nmero contenido dentro de la variable val.

Subiremos el Sketch a la placa y activaremos el monitor serie. No pongo el ejercicio resuelto para que os esforcis un poquito.

El tipo de seal que se le enva alservodesde la placa Arduino UNO es la seal de control que se utiliza en todos los mecanismos de radio control (servos, receptores, variadores, etc.). Es tipo de seal muy concreto que aunque se pueda etiquetar con unas siglas que aqu no voy a utilizar tiene unas caractersticas que me impiden etiquetarla como tal, en breve publicar el apndice de este ejercicio en el que explicar y definir con todo lujo de detalles y ejemplos como son las seales de control de RC.

Este ejercicio est basado en los ejemplos de la pgina oficial:http://arduino.cc/en/Tutorial/Knobhttp://arduino.cc/es/Tutorial/KnobEjercicio 3: seales de control RC

Los elementos de radio control (RC a partir de ahora) nos brindan grandes ventajas a la hora de trabajar con ellos. Por ejemplo unservo de RCes la forma ms sencilla de agregar un actuador mecnico a nuestro proyecto y estn disponibles en tal variedad que es poco probable que no encontremos un modelo que se acople a nuestras necesidades. Otro ejemplo son los ESC o variadores que en RC se encargan de controlar los motores y en nuestro proyecto pueden hacer lo mismo dndonos un control sobre motores DC o brushless de cualquier tamao e incluso, segn el modelo que escojamos, con inversin de giro.

Los elementos de control de RC se comunican entre ellos mediante una seal de control de unas caractersticas muy concretas: se emiten pulsos de entre 1 y 2 milisegundos con una separacin de 20 milisegundos entre sus flancos de subida.

Segn la anchura de ese pulso el elemento de RC al que se lo mandemos har una cosa u otra. Por ejemplo los servos se posicionarn en un ngulo de 0 (posicin de referencia) si el pulso es de 1ms, buscarn la posicin central (90) si el pulso es de 15ms y se establecern en la posicin final (180) si el pulso es de 2ms.

Un ESC (Electronic Speed Controler) o variador adaptar la salida de potencia hacia el motor segn este ancho de pulso y segn sea para aviones o coches se comportar de una forma u otra (los aviones no necesitan inversin de giro, los coches s). As un variador para aviones dejar los motores parados en la posicin de 0 e ir aumentando la velocidad a medida que aumentemos el ngulo que le transmitamos, mientras que un variador para coches mantendr el motor parado en la posicin de 90 y aumentar la velocidad en los rangos de 90 a 0 y en el de 90 a 180 pero en sentidos diferentes.

El movimiento se demuestra andando, as que vamos a generar seales de control de RC desde nuestraArduino UNO. La forma ms sencilla es recurrir a la librera servo.h que viene con el IDE.

Para ello solo tenemos que hacer una llamada a la librera en el bloque inicial del Sketch:

1#include

Luego creamos un objeto para cada elemento que queramos controlar con una seal de control RC

1ServomiActuador;

En el setup() conectaremos el objeto miActuador a un pin digital

1miActuador.attach(7);

Se puede conectar a cualquiera, yo he puesto el 7 por que no est marcado como PWM. Llegado a este punto es hora de una pequea aclaracin: la seal de control RC se genera por software, por lo que se puede emitir por cualquier pin digital de Arduino. No tiene nada que ver con los pines marcados como PWM (aclaracin completa al final del apndice).

Luego en el loop() solo tenemos que insertar all donde sea necesaria una lnea con el comando de llamada al objeto que hemos creado y le decimos en qu posicin queremos que se ponga:

1miActuador.write(posicion);

El valor de posicin puede ser un nmero o una variable previamente declarada y que contenga un entero del rango requerido, es decir, entre 0 y 180. Y ya est, as de sencillo.

Es ms, la seal de control de RC se puede definir como una sucesin de pulsos (de entre 1 y 2 milisegundos) separados por una pausa de 20 milisegundos.

123456789101112131415161718intlectura;// variable que almacenara el valor ledo del potencimetro.intsalida=9;// pin por el que mandaremos un tren de pulsosintpulso;// contendr la anchura del pulso

voidsetup(){pinMode(salida,OUTPUT);}

voidloop(){lectura=analogRead(A0);// leemos el potencimetropulso=map(lectura,0,1023,1000,2000);// calculamos el ancho del pulso en microsegundosdigitalWrite(salida,HIGH);// activamos el pin de salidadelayMicroseconds(pulso);// esperamos el tiempo que dura el pulso en microsegundosdigitalWrite(salida,LOW);// desactivamos el pin de salidadelayMicroseconds(20000);// PAUSA de 20 milisegundos}

Se aparta de lo que es la definicin tanto de PWM como de la seal de control RC pero funciona siempre que el pulso se mantenga dentro del rango de 1 a 2 ms. Este mismo sketch puede ser modificado muy fcilmente para que la pausa (el ciclo bajo) se ajuste a la duracin requerida para que entre los flancos de subida de la seal el tiempo sea de 20ms, lo dejo como un ejercicio para que os entrenis en el bello arte de la programacin.

Ahora vamos a hacer la accin contraria, supongamos que queremos leer una seal de RC que proviene de un receptor. La forma ms sencilla es que a travs de un pin digital cronometremos el pulso mediante el comando pulseIn().

123456789101112131415intentrada=7;// pin en el que meternos la seal que viene del receptorunsignedlongpulso;// variable en la que almacenaremos la lectura

voidsetup(){pinMode(entrada,INPUT);// configuramos el pin como entradaSerial.begin(9600);// habilitamos puerto serie}

voidloop(){pulso=pulseIn(entrada,HIGH);// leemos el pulsoSerial.println(pulso);// mandamos el dato al monitor seriedelay(500);// pausa para no volver loco al monitor serie}

Este sencillo sketch nos devolver por el puerto serie la duracin del pulso en microsegundos. Se trata de una funcin muy til si queremos aplicar control PID o realizar cualquier otra operacin con canales como su mezcla, inversin o cambiar su linealidad por una curva exponencial.

Dentro de los receptores de RC existe una lnea de comunicacin entre la parte que recibe la seal de radio y la parte que separa la seal de control en sus respectivos canales, por lo que es posible leer todos los canales con un solo pin digital. Pero eso depende mucho del tipo de receptor utilizado, ms ahora que se imponen los receptores de 2,4GHz con protocolos propietarios. As que este mtodo lo dejaremos de momento para el nivel avanzado.

Vamos con las puntualizaciones:

Esta seal de control es PWM? Tcnicamente si, se trata de una seal PWM con una frecuencia de 50Hz y un pulso comprendido entre 1 y 2 milisegundos. Es de unas caractersticas tan determinadas que en mi opinin se aparta de la definicin general de PWM y no debe llamarse as para no confundir a los usuarios de Arduino con menos experiencia.Tiene algo que ver con los pines marcados como PWM en la placa Arduino? No, los pines marcados como PWM en la placa Arduino tienen como funcin simular salidas analgicas mediante el comando analogWrite(), la frecuencia de funcionamiento de la seal PWM de Arduino es de 416Hz y el ancho de pulso puede ir del 0% al 100%, por lo que no es ni parecida a la seal de control de RC.Desde Arduino podemos emitir una seal de control RC por cualquiera de sus pines digitales, no necesariamente marcado como PWM, es ms, utilizar los pines marcados como PWM no nos aporta ninguna ventaja pues la seal de control RC se genera por software.De la misma forma para leer una seal de control RC con un Arduino no se puede hacer desde los pines de entrada analgicos, si no que debe hacerse por software mediante el comando pulseIn().

Ejercicio 4: LDR

Elaborado a partir dehttp://www.arduino.cc/playground/Learning/PhotoResistoryhttp://arduino.cc/es/Reference/MapUso de una fotoresistencia como sensor de luzEste es un ejercicio muy sencillo en el que veremos como obtener lecturas analgicas de un sensor y darles salida por el monitor del puerto serie para verlas.

Necesitaremos una placaArduino UNOy una resistencia sensible a la luz ofotoresistenciaTambin utilizaremos unledpara que nos de una salida proporcional a las lecturas recibidas desde la entrada analgica mediante PWM.

123456789101112131415161718192021222324252627282930313233343536/* Prueba simple del funcionamiento de una fotoresistenciaConecta la fotoresistencia por una pata al pin 0 y por laotra a +5V.Conecta una resistencia de 10K entre el pin 0 y GND.----------------------------------------------------PhotoR 10K+5 o---/\/\/--.--/\/\/---o GND |Pin 0 o-------'----------------------------------------------------*/intlightPin=0;// Pin para la fotoresistenciaintledPin=11; // Pin al que se conecta el LED

voidsetup(){Serial.begin(9600); // Inicia la comunicacion seriepinMode(ledPin,OUTPUT);// Establece el pin del LED // como salida}

voidloop(){// Primero leemos el valor que nos da la fotoresistecia// y lo mostramos por el puerto serieSerial.println(analogRead(lightPin));

// Ahora cogemos la lectura de la fotoresistencia, la// dividimos por 4 y la mandamos como salida analogica// al LEDanalogWrite(ledPin,analogRead(lightPin)/4);

// Hacemos una pequea pausa para que el baile de// numeros en el puerto serie no sea mareantedelay(100);}

Ya podemos subir este cdigo a nuestra placa y probar a ver que pasa.

Muy probablemente el resultado sea decepcionante: el LED brilla poco y cuando pasamos la mano por encima de la fotoresistencia el brillo del LED baja un poco ms, pero dependiendo de las condiciones de luz ambiental es probable que no se note apenas nada.

La solucin es el calibrado del sensor, esto es, hacer una lectura de los valores que devuelve el sensor en el ambiente en el que va a trabajar y ajustar los valores de salida a este rango. Para ello emplearemos el comandomap().

map(valor, desdeBajo, desdeAlto, hastaBajo, hastaAlto)valor: el nmero (valor) a mapear.desdeBajo: el lmite inferior del rango actual del valor.desdeAlto: el lmite superior del rango actual del valor.hastaBajo: lmite inferior del rango deseado.hastaAlto: lmite superior del rango deseado.

El comandomap()re-mapea un nmero desde un rango hacia otro. Esto significa que, un valor contenido en el al rango desdeBajo-desdeAlto ser mapeado al rango hastaBajo-hastaAlto.

No se limitan los valores dentro del rango, ya que los valores fuera de rango son a veces objetivos y tiles, as que si le pasamos un valor fuera del rango inicial calcular una salida dentro del rango de salida. Se puede utilizar el comandoconstrain()tanto antes como despus de sta funcin si es importante respetar los lmites de los rangos.

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.El comandomap()usa matemtica de enteros por lo que no generar nmeros en coma flotante, es decir, su uso se limita a valores o variables del tipo int.

Trata de aplicar la funcinmap()al ejercicio por ti mismo, de modo que el LED brille al mnimo cuando tapas con la mano la LDR y al mximo cuando la LDR capta la luz de ambiente. Si tienes dudas, aqu tienes la solucin, aunque te sentirs ms orgulloso si lo resuelves sin mirar.

Programa

intlightPin=0;//define el pin de la foto-resistenciaintledPin=11; //define el pin para el LEDintvalor; //define una variable en la que haremos los clculosintmin=0; //valor mnimo que da la foto-resistenciaintmax=0; //valor mximo que da la foto-resistencia

voidsetup(){ Serial.begin(9600);//Inicializa la comunicacin serie pinMode(ledPin,OUTPUT);}

voidloop(){ valor=analogRead(lightPin); valor=map(valor,min,max,0,255); analogWrite(ledPin,valor); Serial.println(valor); delay(10);//pequeo retardo para darle // tiempo al LED a responder.}

Referencia del Lenguaje

Visita lareferencia extendidapara caractersticas ms avanzadas del Lenguaje Arduino y lapgina de libreraspara estudiar cmo conectar con distintos tipos de hardware.Los programas hechos con Arduino se dividen en tres partes principales:estructura,valores(variables y constantes), yfunciones. El Lenguaje de programacin Arduino se basa en C/C++.

Estructura

setup()(inicializacin) loop()(bucle)Estructuras de control

if(comparador si-entonces) if...else(comparador si...sino) for(bucle con contador) switch case(comparador mltiple) while(bucle por comparacin booleana) do... while(bucle por comparacin booleana) break(salida de bloque de cdigo) continue(continuacin en bloque de cdigo) return(devuelve valor a programa)Sintaxis

;(punto y coma)

{}(llaves)

//(comentarios en una lnea)

/* */(comentarios en mltiples lneas)

Operadores Aritmticos

= (asignacin) + (suma) - (resta) * (multiplicacin) / (divisin) % (resto)Operadores Comparativos

==(igual a)

!=(distinto de)

(mayor que)

=(mayor o igual que)

Operadores Booleanos

&&(y)

||(o)

!(negacin)

Operadores de Composicin

++(incrementa)

--(decrementa)

+=(composicin suma)

-=(composicin resta)

*=(composicin multiplicacin)

/=(composicin divisin)Variables

Constantes

HIGH|LOW INPUT|OUTPUT true|false Constantes NumricasTipos de Datos

boolean(booleano) char(carcter) byte int(entero) unsigned int(entero sin signo) long(entero 32b) unsigned long(entero 32b sin signo) float(en coma flotante) double(en coma flotante de 32b) string(cadena de caracteres) array(cadena) void(vaco)Conversin

char() byte() int() long() float()Funciones

E/S Digitales pinMode()

digitalWrite()

digitalRead()

E/S Analgicas analogRead()

analogWrite() -PWM(modulacin por ancho de pulso)E/S Avanzadas tone()

noTone()

shiftOut()

pulseIn()

Tiempo millis()

micros()

delay()

delayMicroseconds()

Matemticas min()(mnimo) max()(mximo) abs()(valor absoluto) constrain()(limita) map()(cambia valor de rango) pow()(eleva a un nmero) sq()(eleva al cuadrado) sqrt()(raz cuadrada)Trigonometra sin()(seno) cos()(coseno) tan()(tangente)Nmeros Aleatorios randomSeed()

random()

Communicacin SerialEchs algo en falta?Visita lareferencia extendidao lapgina de libreras. Tambin puedes visitar lapgina de cdigo propuesto por la comunidad.

Pgina principal ReferenciaCorrecciones, sugerencias, y nueva documentacin debern ser publicadas en elForo (castellano)o en elForo (ingls).El texto de la referencia de Arduino est publicado bajo la licenciaCreative Commons Reconocimiento-Compartir bajo la misma licencia 3.0. Los ejemplos de cdigo de la referencia estn liberados al dominio pblico.

Ejemplos

Visita lapgina de conceptos bsicospara una descripcin en profundidad de los conceptos centrales del hardware y software Arduino; lapgina de hackingpara informacin en cmo ampliar y modificar el hardware y software Arduino; y lapgina de enlacespara otro tipo de documentacin.Tambin hay unagua de estilotil al esribir ejemplos para principiantes.

Conceptos Bsicos

Pequeos programas que demuestran los comandos bsicos de Arduino. Estos vienen por defecto con el entorno de desarrollo Arduino; para abrirlos en tu ordenador, haz click en el botnOpende la barra de herramientas y la carpetaexampleso en el menFile -> Examplesdnde los encontrars agrupados por temticas.

Entradas/Salidas Digitales

Blink:parpadeo, enciende y apaga un LED.

Blink Without Delay:parpadeo sin delay, enciende y apaga el LED sin usar la funcindelay().

Button:botn, control de un LED usando un pulsador.

Button State Change:cambio de estado del botn, cuenta del nmero de veces que se presiona un botn.

Debounce: lee un pulsador, filtrando el ruido.

Tone:tono, toca una meloda usando un Piezo.

Pitch follower:seguidor de pitch, cambia el pitch de un tono usando una entrada analgica.

Simple Keyboard:teclado simple, un teclado musical de slo tres teclas usando sensores de fuerza y un Piezo.

Tone4: toca tonos en varios altavoces secuencialmente usando el comandotone().

Entradas/Salidas Analgicas

Analog Input:entrada analgica, usa un potenciometro para controlar la frecuencia de parpadeo de un LED.

Calibration:calibracin, para lecturas de sensores analgicos.

Fading: emplea una salida analgica (por modulacin de ancho de pulso -PWM) para cambiar la intensidad lumnnica de un LED de forma gradual.

Smoothing:suavizado, suaviza multiples lecturas de una entrada analgica.

Estructuras de Control

Proposicin If(estrucutura condicional): cmo usar la proposicinifpara cambiar las condiciones de salida en funcin de las condiciones de entrada.

Bucle For: controlar mltiplesLEDsusando un bcle.

Array: una variacin del ejemplo anterior demostrando cmo usar unarray.

Bucle While: uso de un buclewhilepara calibrar un sensor mientras se aprieta un botn.

Switch Case: cmo discriminar entre distintos valores numricos. Equivalente a una serie de proposicionesifencadenadas. Este ejemplo muestra como dividir el rango de un sensor de entrada en cuatro bandas y cmo tomar diferentes acciones en funcin de la banda en la que caiga el valor del sensor.

Switch Case 2: un segungo ejemplo conswitch-case, muestra como tomar diferentes acciones basado en los caracteres recibidos por el puerto serie.

Sensores

ADXL3xx: Lee un sensor acelermetro tipoADXL3xx.

Knock: usa un piezo para detectar vibraciones.

Memsic2125: acelermetro de doble eje.

Ping: detecta objetos con un sensor de ultrasonidos.

Comunicacin

Estos ejemplos incluyen cdigo que permite a Arduino comunicar consketchesde Processing corriendo en el ordenador. Para ms informacin o para descargar Processing, visitaprocessing.org.Hay tambinpatchespara Max/MSP que pueden comunicar con Arduino. Para ms informacin acerca de Max/MSP, visita la web deCycling 74 ASCII Table:Tabla ASCII, demostracin de las funciones avanzadas de comunicacin serie de Arduino.

Dimmer: mueve el ratn para cambiar la intensidad de un LED.

Graph: enva datos al ordenador y crea grficos con Processing.

Physical Pixel:pixel fsico, enciende y apaga un LED en la placa al enviar datos desde Processing.

Virtual Color Mixer:mezclador de colores virtual, enva una serie de variables desde Arduino al ordenador y leelas en Processing.

Serial Call Response:respuesta a llamadas serie, enva variables en respuesta a una peticin (handshake).

Serial Call Response ASCII:respuesta ASCII a llamadas serie, enva variables en respuesta a una peticin (handshake), codifica los valores usando el cdigo ASCII antes de enviarlos.

Serial input:entrada serie, toma diferentes acciones en funcin de los datos que llegan por el puerto serie.

MIDI: enva notas MIDI por el puerto serie.

Mostrando Informacin (Display)

Ejemplos bsicos para mostrar informacin.

Bar Graph: cmo hacer un grfico de barras conLEDs.

Row Column Scanning:escano en filas y columnas, control de una matriz de 8x8LEDs