Vous êtes sur la page 1sur 55

2012

Manual de Practicas Arduino


Alejandro Campos Martnez CONALEP Nayarit, Plantel Tepic 169
Esta gua lo llevara a conocer, dentro de un entorno bsico, las capacidades de Arduino, de tal manera que comenzaremos desde la instalacin hasta nuestros primeros proyectos basados en sistemas embebidos basados en Hardware Libre.

Contenido
Qu es Arduino? ............................................................................................................................. 3 Porque usar Arduino? .................................................................................................................... 3 Definiciones ....................................................................................................................................... 4 Instalacin ......................................................................................................................................... 5 Conecta la placa Arduino ............................................................................................................ 5 Instala los drivers ......................................................................................................................... 6 ARDUINO UNO ...................................................................................................................... 6 Configuracin del IDE ..................................................................................................................... 7 Conociendo nuestro Arduino ......................................................................................................... 8 Entradas y salidas de datos ......................................................................................................... 8 Especificaciones Generales de Arduino UNO y Leonardo .................................................... 8 PRACTICAS ...................................................................................................................................... 9 1.- HOLA MUNDO ...................................................................................................................... 9 Practica 2 .......................................................................................................................................... 11 Alarma ......................................................................................................................................... 11 Practica 3 .......................................................................................................................................... 14 Secuencia de LEDs ..................................................................................................................... 14 Practica 4 .......................................................................................................................................... 16 Interruptor ................................................................................................................................... 16 Practica 5 .......................................................................................................................................... 19 Lectura de Sensor Magntico (Reed switch) .......................................................................... 19 Practica 6 .......................................................................................................................................... 20 Lectura de Seales Analgicas ................................................................................................. 20 Practica 7 .......................................................................................................................................... 23 Secuenciales................................................................................................................................. 23 Auto Fantstico 1 .................................................................................................................... 23 AutoFantastico 2 ..................................................................................................................... 26 Practica 8 .......................................................................................................................................... 29 Estrella Fugaz .......................................................................................................................... 29

pg. 1

Practica 9 .......................................................................................................................................... 32 Contador ...................................................................................................................................... 32 Prctica 10 ........................................................................................................................................ 35 Contador 0 al 10 .......................................................................................................................... 35 Prctica 11 ........................................................................................................................................ 38 Entrada Analgica monitoreada por pc .................................................................................. 38 Practica 12 ........................................................................................................................................ 40 Vela ............................................................................................................................................... 40 Introduccin a PWM .............................................................................................................. 40 Practica 13 ........................................................................................................................................ 42 Monitor de Nivel ........................................................................................................................ 42 Practica 14 ........................................................................................................................................ 44 Niveles de Iluminacin .............................................................................................................. 44 Practica 15 ........................................................................................................................................ 45 Sensores Resistivos LDR- ........................................................................................................ 45 Practica 16 ........................................................................................................................................ 48 Sensores Resistivos NTC- ........................................................................................................ 48 Practica 17 ........................................................................................................................................ 51 Sensor de Fuerza......................................................................................................................... 51

pg. 2

Qu es Arduino?
Arduino es una herramienta para hacer que las computadoras puedan sentir y controlar el mundo fsico a travs de tu computadora personal. Es una plataforma de desarrollo de computacin fsica (physical computing) de cdigo abierto, basada en una tarjeta con un sencillo microcontrolador y un entorno de desarrollo para crear software (programas) para la tarjeta.

Porque usar Arduino?


Hay muchos otros microcontroladores y plataformas con microcontroladores disponibles para la computacin fsica. Parallax Basic Stamp, BX-24 de Netmedia, Phidgets, Handyboard del MIT, y muchos otros ofrecen funcionalidades similares. Todas estas herramientas organizan el complicado trabajo de programar un microcontrolador en paquetes fciles de usar. Arduino, adems de simplificar el proceso de trabajar con microcontroladores, ofrece algunas ventajas respecto a otros sistemas a profesores y estudiantes: Accesible - Las placas Arduino son ms accesibles comparadas con otras plataformas de microcontroladores. La versin ms cara de un mdulo de Arduino puede ser montada a mano, e incluso ya montada cuesta menos de $500.00 MX ($35.00 US) Multi-Plataforma - El software de Arduino funciona en los sistemas operativos Windows, Macintosh OSX, Android y Linux. La mayora de los entornos para microcontroladores estn limitados a Windows. Entorno de programacin simple y directo - El entorno de programacin de Arduino es fcil de usar para principiantes y lo suficientemente flexible para los usuarios avanzados. Software ampliable y de cdigo abierto- El software Arduino est publicado bajo una licencia libre y preparado para ser ampliado por programadores experimentados. El lenguaje puede ampliarse a travs de libreras de C++, y si se est interesado en profundizar en los detalles tcnicos, se puede dar el salto a la programacin en el lenguaje AVR C en el que est basado. De igual modo se puede aadir directamente cdigo en AVR C en tus programas si as lo deseas.

pg. 3

Hardware ampliable y de Cdigo abierto - Arduino est basado en los microcontroladores ATMEGA168, ATMEGA328 y ATMEGA1280. Los diagramas esquemticos de los mdulos estn publicados bajo licencia Creative Commons, por lo que diseadores de circuitos con experiencia pueden hacer su propia versin del mdulo, amplindolo u optimizndolo. Incluso usuarios relativamente inexpertos pueden construir la versin para placa de desarrollo para entender cmo funciona y ahorrar algo de dinero.

Definiciones
IDE Un IDE (sigla en ingls de integrated development environment) o Entorno de Desarrollo Integrado. Un IDE es un entorno de programacin que ha sido empaquetado como un programa de aplicacin, es decir, consiste en un editor de cdigo, un compilador, un depurador y un constructor de interfaz grfica (GUI). BOOT En informtica, la secuencia de arranque, (boot o booting en ingls) es el proceso que inicia el sistema operativo cuando el usuario enciende una computadora. Se encarga de la inicializacin del sistema y de los dispositivos. Boot Loader Un cargador de arranque ( "bootloader" en ingls) es un programa sencillo (que no tiene la totalidad de las funcionalidades de un sistema operativo) diseado exclusivamente para preparar todo lo que necesita el sistema operativo para funcionar. Normalmente se utilizan los cargadores de arranque multietapas, en los que varios programas pequeos se suman los unos a los otros, hasta que el ltimo de ellos carga el sistema operativo. Embedded system Un sistema embebido es un sistema de computacin diseado para realizar una o algunas pocas funciones dedicadas en un sistema de computacin en tiempo real. Al contrario de lo que ocurre con los ordenadores de propsito general (como por ejemplo una computadora personal o PC) que estn diseados para cubrir un amplio rango de necesidades, los sistemas embebidos se disean para cubrir necesidades especficas. En un

pg. 4

sistema embebido la mayora de los componentes se encuentran incluidos en la placa base (la tarjeta de vdeo, audio, mdem, etc.) y muchas veces los dispositivos resultantes no tienen el aspecto de lo que se suele asociar a una computadora. Algunos ejemplos de sistemas embebidos podran ser dispositivos como un taximetro, un sistema de control de acceso, la electrnica que controla una mquina expendedora o el sistema de control de una fotocopiadora entre otras mltiples aplicaciones. Por lo general los sistemas embebidos se pueden programar directamente en el lenguaje ensamblador del microcontrolador o microprocesador incorporado sobre el mismo, o tambin, utilizando los compiladores especficos, pueden utilizarse lenguajes como C o C++; en algunos casos, cuando el tiempo de respuesta de la aplicacin no es un factor crtico, tambin pueden usarse lenguajes interpretados como JAVA. En el caso de Arduino la programacin se hace con un lenguaje de programacin llamado Arduino, el cual se encuentra basado en otro lenguaje de programacin, Wiring.

Instalacin
Descarga la ltima versin del IDE de Arduino de la pgina de descargas: http://arduino.cc/en/Main/Software La ltima versin que se encuentra a la fecha de la edicin de este documento es la 1.0.1, es la versin con la cual trabajaremos en este manual. http://arduino.googlecode.com/files/arduino-1.0.1-windows.zip Cuando la descarga finalice, descomprime el archivo (arduino-1.0.1-windows.zip). Asegrate de mantener la estructura de directorios. Haz doble click en la carpeta arduino1.0.1 para abrirla. Deberas ver una serie de ficheros y carpetas ah dentro.

Conecta la placa Arduino

Conecta la placa Arduino a tu computadora usando el cable USB. El LED verde indicador de la alimentacin (nombrado como PWR en la placa) debera quedar encendido a partir de ese momento.

pg. 5

Instala los drivers

Cuando conectas la placa, Windows debera inicializar la instalacin de los drivers (siempre y cuando no hayas utilizado esa computadora con una placa Arduino anteriormente). En Windows Vista y Windows 7, los drivers deberan descargarse e instalarse automticamente. En Windows XP, se abrir el dilogo de instalacin de Nuevo Hardware: Cuando te pregunte el cuadro de dialogo: Puede Windows conectarse a Windows Update para buscar el software? Selecciona No, no esta vez. Haz click en Siguiente. Selecciona Instalar desde una lista o localizacin especfica (Avanzado) haz click en Siguiente. Asegrate que Buscar los mejores drivers en estas localizaciones est seleccionado; deselecciona Buscar en medios removibles; selecciona Incluye esta localizacin en la bsqueda y navega al directorio drivers/FTDI USB Drivers dentro de la carpeta de Arduino que has descomprimido previamente. (La versin ms reciente de los drivers se puede encontrar en la pgina web del fabricante del chip FTDI.) Haz click en Siguiente. ARDUINO UNO El asistente de instalacin buscar los drivers y te anunciar que encontr un "USB Serial Converter" (se traduce por Conversor USB-Serie). Haz click en Finalizar. El asistente de instalacin de hardware volver a iniciarse. Repite los mismos pasos que antes y selecciona la misma carpeta de instalacin de los drivers. Esta vez el sistema encontrar un "USB Serial Port" (o Puerto USB-Serie). Puedes comprobar que los drivers se han instalado correctamente abriendo la carpeta del Administrador del Dispositivos, en el grupo Dispositivos del panel de control del sistema. Busca "USB Serial Port" (o Puerto USB-Serie) en la seccin de puertos; esa es tu placa Arduino.

pg. 6

Configuracin del IDE


Entra a la carpeta que descomprimiste, busca y ejecuta el archivo Arduino.exe

Una vez abierto el IDE de Arduino busca la pestaa Herramientas, y da clic en Tarjeta. Selecciona el tipo de Arduino que tienes (UNO o LEONARDO).

Nuestro IDE estar ahora configurado para realizar nuestros primeros programas.

pg. 7

Conociendo nuestro Arduino


Entradas y salidas de datos

Consta de 14 pines configurables como entrada/salidas (I/O) digitales que operan a 5 volts. Cada pin puede proporcionar o recibir como mximo 40 mA. Los pines 3, 5, 6, 8, 10 y 11 pueden proporcionar una salida PWM (Pulse Wide Modulation). Si se conecta cualquier cosa a los pines 0 y 1, eso interferir con la comunicacin USB. Los pines 0 y 1 pueden ser utilizados como puerto de comunicacin serial, para poder enlazar algn Shield, Arduino o cualquier otro dispositivo que utilice protocolo de comunicacin serial RS232. Tambin tiene 6 entradas analgicas que proporcionan una resolucin de 10 bits. Por defecto miden de 0 voltios (negativo) hasta 5 volts, aunque es posible cambiar el nivel ms alto, utilizando el pin Aref y algn cdigo de bajo nivel.

Especificaciones Generales de Arduino UNO y Leonardo

DESCRIPCIN Voltaje de Operacin (Va USB) Voltaje de Entrada Recomendado (Va entrada de alimentacin) Voltaje Mximo (Va USB) Voltaje Mximo (Va entrada de alimentacin) Intensidad mxima en los pines de Entrada/Salida Memoria Flash (UNO) Memoria Flash (LEONARDO) Velocidad de Reloj (Clock)

Cantidad 5 5 -12 6 20 40 32 32 16

Prefijo ----------------------m K K M

Unidad S.I. Volt Volt Volt Volt A b b Hz

pg. 8

PRACTICAS
1.- HOLA MUNDO
En informtica, un programa Hola Mundo o Hello World es el que imprime el texto <<Hola Mundo!>> en un dispositivo de visualizacin, sea monitor o pantalla. Se suele usar como introduccin al estudio de un lenguaje de programacin, siendo este el primer ejercicio tpico y se considera como uno de los programas fundamentales desde el punto de vista didctico. Visto en Arduino, nuestro Hola Mundo ser un programa que logre encender y apagar un led en un tiempo determinado. Objetivo de la Prctica: Encender y apagar un LED de manera continua con un intervalo de tiempo de un segundo. Resultado de Aprendizaje: Conocer el entorno de desarrollo (IDE) de Arduino.

HOLA MUNDO

Configuracin E/S
SD PIN 13

ACTIVAR SALIDA PIN 13

DELAY (1000 ms)

DESACTIVAR SALIDA
Practica 1

PIN 13

DELAY (1000 ms)

pg. 9

Cdigo Fuente: /* Blink Enciende un LED por un segundo, luego lo apaga por otro segundo, y esto se repite siempre. Este ejemplo de cdigo es de Dominio pblico */

// Como estamos usando el pin nmero 13 de la placa Arduino, creamos una variable de tipo entero y la llamamos led int led = 13;

//La funcin de configuracin debe contenerla declaracin de las variables. Es la primera funcin a ejecutar en el programa, se ejecuta slo una vez, y se utiliza para configura inicializar pinMode (modo de trabajo de las E/S), configuracin de la comunicacin en serie y otras. void setup() { // Inicializa la salida digital como una salida pinMode(led, OUTPUT); }

// La funcin loop repite la rutina por siempre: void loop() { digitalWrite(led, HIGH); voltaje es ALTO) delay(1000); digitalWrite(led, LOW); es BAJO) delay(1000); } // Enciende el LED (El nivel de // espera un segundo // apaga el LED (El nivel de voltaje // espera un segundo

pg. 10

Practica 2
Alarma

Un sistema de alarma es un elemento de seguridad pasiva. Esto significa que no evitan una situacin anormal, pero s son capaces de advertir de ella, cumpliendo as, una funcin disuasoria frente a posibles problemas. Por ejemplo: La intrusin de personas. Inicio de fuego. El desbordamiento de un tanque. La presencia de agentes txicos. Cualquier situacin que sea anormal para el usuario. Son capaces adems de reducir el tiempo de ejecucin de las acciones a tomar en funcin del problema presentado. Una vez que la alarma comienza a funcionar, o se activa dependiendo del sistema instalado, este puede tomar acciones en forma automtica. Por ejemplo: Si se detecta la intrusin de una persona a un rea determinada, mandar un mensaje telefnico a uno o varios nmeros. Si se detecta la presencia de humo, calor o ambos, mandar un mensaje telefnico a uno o varios nmeros o accionar la apertura de rociadores en el techo, para que apaguen el fuego. Si se detecta la presencia de agentes txicos en un rea, cerrar las puertas para que no se expanda el problema. Para esto, la alarma tiene que tener conexiones de entrada, para los distintos tipos de sensores, y conexiones de salida, para activar otros dispositivos que son los que se ocupan de hacer sonar la sirena, abrir los rociadores, cerrar las puertas o cualquier otro sistema con el cual se pretenda generar una alerta.

pg. 11

pg. 12

Cdigo Fuente:

int ledPin= 13; // Declara la variable para el LED int inPin= 5; // Declara la variable de entrada (para un pushbutton) int val= 0; // Variable para leer el estado del pin de entrada void setup() { pinMode(ledPin, OUTPUT); // Declara LED como salida pinMode(inPin, INPUT); // Declara pushbutton como entrada } void loop(){ val= digitalRead(inPin); // lee valor de entrada if(val== HIGH) { // Verifica si el valor ledo es 1 (botn presionado) digitalWrite(ledPin, LOW); // pone el LED en OFF } else{ digitalWrite(ledPin, LOW); // parpadea el LED delay(200); digitalWrite(ledPin, HIGH); delay(200); } }

pg. 13

Practica 3
Secuencia de LEDs

Muchas veces hemos visto en letreros luminosos una serie de luces que encienden y dan efecto de movimiento, prendiendo estas de manera secuencial. Esta actividad consiste en un diseo secuencial de LEDs,

el cual puede ser implementado hasta con catorce salidas.

pg. 14

// Encendido y apagado de 3 LEDs int ledPin1 = 10; // Define la salida de los LEDs int ledPin2 = 11; // Define la salida de los LEDs int ledPin3 = 12; int ledPin4 = 13; // Define la salida de los LEDs // Define la salida de los LEDs

void setup() { // Configura las SALIDAS pinMode(ledPin1, OUTPUT); // declara LED como salida pinMode(ledPin2, OUTPUT); // declara LED como salida pinMode(ledPin3, OUTPUT); // declara LED como salida pinMode(ledPin4, OUTPUT); // declara LED como salida digitalWrite(ledPin1, LOW); // Apaga LED digitalWrite(ledPin2, LOW); // Apaga LED digitalWrite(ledPin3, LOW); digitalWrite(ledPin4, LOW); } void loop(){ //Bucle de Funcionamiento digitalWrite(ledPin1, HIGH); // Enciende LED delay(200); // Mantiene encendido el LED 200ms digitalWrite(ledPin1, LOW); //Apaga LED digitalWrite(ledPin2, HIGH); // Enciende LED delay(200); // Mantiene encendido el LED 200ms digitalWrite(ledPin2, LOW); //Apaga LED digitalWrite(ledPin3, HIGH); //Enciende LED delay(200); // Mantiene encendido el LED 200ms digitalWrite(ledPin3, LOW); //Apaga LED digitalWrite(ledPin4, HIGH); //Enciende LED delay(200); // Mantiene encendido el LED 200ms digitalWrite(ledPin4, LOW); //Apaga LED } // Apaga LED // Apaga LED

pg. 15

Practica 4
Interruptor

Un interruptor elctrico es en su acepcin ms bsica un dispositivo que permite desviar o interrumpir el curso de una corriente elctrica. En electrnica se denomina pull-up a la accin de elevar la tensin de salida de un circuito lgico, a la tensin que, por lo general mediante un divisor de tensin, se pone a la entrada de un amplificador con el fin de desplazar su punto de trabajo, y se denomina pull-down a la accin inversa.

pg. 16

Implementaremos un sistema de control con interruptor bsico, usando para ello las entradas digitales de Arduino y un circuito pullup y utilizaremos como monitor un LED que permita ver cuando el interruptor se encuentra presionado.

pg. 17

/* Pulsador * -------* * Detecta si el botn ha sido presionado o no * y enciende el LED en consecuencia. * * Massimo Banzi * */ int ledPin = 13; // PIN del LED int inPin = 10; // PIN del pulsador int valor = 0; // Valor del pulsador void setup() { pinMode(ledPin, digital pinMode(inPin, digital } void loop() { valor = digitalRead(inPin); // Lee el valor de la entrada digital digitalWrite(ledPin, valor); // Escribe el valor de la entrada digital } OUTPUT); INPUT); // // Inicializa Inicializa el el pin pin 13 10 como como salida entrada

pg. 18

Practica 5
Lectura de Sensor Magntico (Reed switch)

El cdigo de ejemplo es el mismo que se emple para la prctica nmero 4, solo que aqu sustituiremos el interruptor por un sensor magntico (Reed Switch). Usamos arreglo resistivo pull-up conectamos el sensor al pin de entrada digital que leeremos cuando lo necesitemos. Cuando acerquemos un imn al sensor este se habilitara y con ello se activara el LED.

** Reed Switch: Catalogo Steren http://bit.ly/ScrCkk

pg. 19

Practica 6
Lectura de Seales Analgicas

Para esta prctica utilizaremos las entradas analgicas de Arduino, utilizando un potencimetro que nos servir para poder variar los valores de entrada. La resistencia variable es un dispositivo que tiene un contacto mvil que se mueve a lo largo de la superficie de una resistencia de valor total constante. Este contacto mvil se llama cursor o flecha y divide la resistencia en dos resistencias cuyos valores son menores y cuya suma tendr siempre el valor de la resistencia total.

pg. 20

pg. 21

/* Potencimetro * -----------------* * enciende y apaga un LED conectado al pin digital #13; * La cantidad de tiempo que el LED parpadear depende del * valor obtenido mediante analogRead(). En este caso al pin 1 * * * Created 1 December 2005 * copyleft 2005 DojoDave <http://www.0j0.org> * http://arduino.berlios.de * */ int potPin = 1; // seleccionar el pin de entrada analgico para el potencimetro int ledPin = 13; // seleccionar el pin de salida digital para el LED int valor = 0; // variable para almacenar el valor capturado desde el sensor void setup() { pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida } void loop() { valor = analogRead(potPin); // lee el valor del sensor digitalWrite(ledPin, HIGH); // enciende LED delay(valor); // detiene el programa por un tiempo val digitalWrite(ledPin, LOW); // apaga el LED delay(valor); // detiene el programa por un tiempo val }

pg. 22

Practica 7
Secuenciales
Auto Fantstico 1

Este prctica se llama "El carro fantstico" en memoria de la serie de TV de los aos 80 en la que el famoso David Hasselhoff tena una mquina de IA (Inteligencia Artificial) conduciendo su Pontiac. El coche estaba equipado con gran cantidad de LED-s de todos los tamaos posibles que realizaban efectos parpadeantes. Esta prctica hace uso de 6 LED-s conectados a los PIN 2 a 7 de la placa mediante resistencias de 220 Ohmios. El primer cdigo de ejemplo hace parpadear a los LED en secuencia de uno en uno, utilizando slo las funciones digitalWrite(pinNum,HIGH/LOW) y delay(time). El segundo ejemplo muestra como usar una secuencia de control for(;;;) para hacer lo mismo, pero en menos lneas de cdigo. El tercer y ltimo ejemplo se centra en el efecto visual de apagar y encender los LED-s de una forma ms suave.

pg. 23

/* El coche fantstico 1 * --------------------* * Bsicamente una extensin BLINK. * * * (cleft) 2005 K3, Malmo University * @author: David Cuartielles * @hardware: David Cuartielles, Aaron Hallborg */ int pin2 = 2; // PIN-es de los LED int pin3 = 3; int pin4 = 4; int pin5 = 5; int pin6 = 6; int pin7 = 7; int timer = 100; // Temporizador void setup(){ pinMode(pin2, OUTPUT); // Configuracin de los PIN-es como salida pinMode(pin3, OUTPUT); pinMode(pin4, OUTPUT); pinMode(pin5, OUTPUT); pinMode(pin6, OUTPUT); pinMode(pin7, OUTPUT); } void loop() { digitalWrite(pin2, HIGH); // Enciende y apaga secuencialmente LEDs delay(timer);

pg. 24

digitalWrite(pin2, LOW); delay(timer); digitalWrite(pin3, HIGH); delay(timer); digitalWrite(pin3, LOW); delay(timer); digitalWrite(pin4, HIGH); delay(timer); digitalWrite(pin4, LOW); delay(timer); digitalWrite(pin5, HIGH); delay(timer); digitalWrite(pin5, LOW); delay(timer); digitalWrite(pin6, HIGH); delay(timer); digitalWrite(pin6, LOW); delay(timer); digitalWrite(pin7, HIGH); delay(timer); digitalWrite(pin7, LOW); delay(timer); digitalWrite(pin6, HIGH); delay(timer); digitalWrite(pin6, LOW); delay(timer); digitalWrite(pin5, HIGH); delay(timer); digitalWrite(pin5, LOW);

pg. 25

delay(timer); digitalWrite(pin4, HIGH); delay(timer); digitalWrite(pin4, LOW); delay(timer); digitalWrite(pin3, HIGH); delay(timer); digitalWrite(pin3, LOW); delay(timer); } AutoFantastico 2

Esta prctica el efecto ser el mismo que el anterior, solo que utilizaremos la sentencia for.

La declaracin for se usa para repetir un bloque de sentencias encerradas entre llaves un nmero determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condicin.

Tambien usaremos un tipo de datos llamado Arrays.

Un array es un conjunto de

valores a los que se accede con un nmero ndice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el nmero del ndice. El primer valor de la matriz es el que est indicado con el ndice 0, es decir el primer valor del conjunto es el de la posicin 0.

pg. 26

pg. 27

/* El coche fantstico 2 * Reduciendo las lneas de cdigo usando un for(;;). * (cleft) 2005 K3, Malmo University * @author: David Cuartielles * @hardware: David Cuartielles, Aaron Hallborg */ int pinArray[] = {2, 3, 4, 5, 6, 7}; // Define el array de pines int count = 0; // Contador int timer = 100; // Temporizador void setup(){ for (count=0;count<6;count++){ // Configuramos todos los PIN-es pinMode(pinArray[count], OUTPUT); } } void loop() { // Enciende y apaga secuencialmente los LED-s for (count=0;count<6;count++) control for(;;) { // utilizando la secuencia de

digitalWrite(pinArray[count], HIGH); // Recorrido de ida delay(timer); digitalWrite(pinArray[count], LOW); delay(timer); } for (count=5;count>=0;count--) { digitalWrite(pinArray[count], HIGH); // Recorrido de vuelta delay(timer); digitalWrite(pinArray[count], LOW); delay(timer); } }

pg. 28

Practica 8
Estrella Fugaz

Esta prctica simula el desplazamiento de una estrella fugaz a travs de una lnea de LEDs y la programacin es muy similar a la del auto fantstico. El programa comienza encendiendo LED-s hasta que llegue al nmero de LEDs establecido para la cola. En ese momento seguir encendiendo LEDs hacia la izquierda para mantener el movimiento de la estrella, al mismo tiempo que apaga LED-s por la derecha, para asegurarnos de que vemos la cola. De otra forma seguira encendiendo LED hasta encenderlos todos. Esto ocurre cuando el tamao de la cola es igual o mayor que el nmero de LED. El tamao de la cola debera ser relativamente pequeo en comparacin con el nmero de LED de forma que podamos ver la estrella.

pg. 29

/* Estrella fugaz * Este programa es una variante del ejemplo del coche fantstico. Muestra mediante * un loop una estrella fugaz que es dibujada en una lnea de LED-s * directamente conectados velocidad a la que a la placa Arduino. Puedes controlar la

* la estrella se mueve gracias a una variable llamada "waitNextLed". Tambin * puedes controlar la longitud de la cola de la estrella a travs de la variable "tail * length" * @author: Cristina Hoffmann */ // Variable declaracin // Declaracin de los PIN-es mediante un array int pinArray [] = { 2,3,4,5,6,7,8,9,10,11,12 }; int controlLed = 13; // LED de control int waitNextLed = 100; // Tiempo antes de encender el siguiente LED // Nmero de LED-s que permanecen encendidos antes de empezar a apagarlos para //formar la cola int tailLength = 4; // Nmero de LED-s conectados (que es tambin el tamao del array) int lineSize = 11; void setup() // Configuracin de los PIN-es como salida digital { int i; pinMode (controlLed, OUTPUT); for (i=0; i< lineSize; i++) { pinMode(pinArray[i], OUTPUT); } }

pg. 30

void loop() { int i; // Se establece la longitud de la cola en un contador int tailCounter = tailLength; // Se enciende el LED de control para indicar el inicio del loop digitalWrite(controlLed, HIGH); for (i=0; i<lineSize; i++) { digitalWrite(pinArray[i],HIGH); // Se encienden consecutivamente los LED // Esta variable de tiempo controla la velocidad a la que se mueve la estrella delay(waitNextLed); if (tailCounter == 0) { // Se apagan los LED-s en funcin de la longitud de la cola. digitalWrite(pinArray[i-tailLength],LOW); } else if (tailCounter > 0) tailCounter--; } for (i=(lineSize-tailLength); i<lineSize; i++) { digitalWrite(pinArray[i],LOW); // Se apagan los LED // Esta variable de tiempo controla la velocidad a la que se mueve la estrella delay(waitNextLed); } }

pg. 31

Practica 9
Contador

Se trata de contar las veces que se pulsa un botn conectado en la entrada 10 de Arduino a la vez que cada vez que contamos encendemos el LED conectado en la salida 13. El valor de la variable que almacena el nmero de impulsos generados se enva al PC para que se visualice en la pantalla.

pg. 32

pg. 33

/* Programa Contador * ----------* * Detecta si el botn conectado a la entrada 10 ha sido presionado y enciende el LED * Enva al PC el valor de la variable de cuenta ""Contador" va puerto serie. * * Christian Nold & Erica Calogero * */ int LED = 13; int Boton = 10; int valor = 0; int contador = 0; int estadoanteriorboton = 0; void setup() { Serial.begin(9600); // Configura velocidad de transmisin a 9600 pinMode(LED, OUTPUT); // inicializa como salida digital el pin 13 pinMode(Boton, INPUT); // inicializa como entrada digital el pin 10 } void loop() { valor = digitalRead(Boton); // lee el valor de la entrada digital pin 10 digitalWrite(LED, valor); if(valor != estadoanteriorboton){ if(valor == 1){ contador++;

pg. 34

Serial.println(contador); Serial.write(10); Serial.write(13); } } estadoanteriorboton = valor; }

Prctica 10
Contador 0 al 10

Esta prctica consiste en contar las veces que se pulsa un botn conectado en la entrada 7 de Arduino a la vez que cada vez que contamos encendemos el LED conectado en la salida 13. El valor de la variable que almacena el nmero de impulsos generados se enva al PC para que se visualice en la pantalla.

pg. 35

pg. 36

/* Programa Contador de 0 a 10 * ----------* * Detecta si el botn conectado a la entrada 7 ha sido presionado y enciende el LED * Enva al PC el valor de la variable de cuenta ""Contador" va puerto serie. * * Christian Nold & Erica Calogero * */ int LED = 13; int Boton = 10; int valor = 0; int contador = 0; int estadoanteriorboton = 0; void setup() { Serial.begin(9600); // Configura velocidad de transmisin a 9600 pinMode(LED, OUTPUT); // inicializa como salida digital el pin 13 pinMode(Boton, INPUT); // inicializa como entrada digital el 10 } void loop() { valor = digitalRead(Boton); // lee el valor de la entrad digital pin 10 digitalWrite(LED, valor); if(valor != estadoanteriorboton){ if(valor == 1){ contador++; Serial.println(contador);
pg. 37

Serial.write(10); Serial.write(13); if (contador==10) { // Limita la cuenta al valor 10 contador=0; } } } estadoanteriorboton = valor; }

Prctica 11
Entrada Analgica monitoreada por pc

En esta prctica configuraremos un canal de entrada analgico y enviar el valor ledo al PC para visualizarlo por comunicacin serial.

pg. 38

/* Entrada Analgica */ int potPin = 5; // selecciona el pin de entrada para colocar el potencimetro int valor = 0; // variable para almacenar el valor ledo por la entrada analgica void setup() { Serial.begin (9600); } void loop() { valor = analogRead(potPin); // lee el valor del canal de ENTRADA analgica Serial.println(valor); // Enva al PC el valor analgico ledo y lo muestra en pantalla Serial.write(10); delay(100); }

pg. 39

Practica 12
Vela
Introduccin a PWM

La Modulacin por Ancho de Pulso (PWM = Pulse Width Modulation) es una tcnica para simular una salida analgica con una salida digital. El control digital se usa para crear una onda cuadrada, una seal que conmuta constantemente entre encendido y apagado. Este patrn de encendido-apagado puede simular voltajes entre 0 (siempre apagado) y 5 voltios (siempre encendido) simplemente variando la proporcin de tiempo entre encendido y apagado. A la duracin del tiempo de encendido (ON) se le llama Ancho de Pulso (pulse width). Para variar el valor analgico cambiamos, o modulamos, ese ancho de pulso. Si repetimos este patrn de encendido-apagado lo suficientemente rpido por ejemplo con un LED el resultado es como si la seal variara entre 0 y 5 voltios controlando el brillo del LED. En el grfico de abajo las lneas verdes representan un periodo regular. Esta duracin o periodo es la inversa de la frecuencia del PWM. En otras palabras, con la Arduino la frecuencia PWM es bastante prxima a 500Hz lo que equivale a periodos de 2 milisegundos cada uno. La llamada a la funcin analogWrite() debe ser en la escala desde 0 a 255, siendo 255 el 100% de ciclo (siempre encendido), el valor 127 ser el 50% del ciclo (la mitad del tiempo encendido), etc.

Para consulta ms especfica sobre PWM en Arduino: http://arduino.cc/es/Tutorial/SecretsOfArduinoPWM

pg. 40

Arduino UNO LEONARDO

SALIDAS PWM 3, 5, 6, 9, 10 y 11 3, 5, 6, 9, 10, 11, y 13

/* * Luz de vela * Saca por una de las salidas del puerto PWM un valor aleatorio que activa un LED * * 2007 Tod E. Kurt <tod@todbot.com> * http://todbot.com/ * */ int ledPin = 13; // selecciona el puerto consultando la tabla PWM

pg. 41

int val = 0; // define y pone a cero la variable "brillo" int delayval = 0; // define el intervalo de cambio de valor de salida void setup() { randomSeed(0); // inicializa el generador de nmeros aleatorios pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9 } void loop() { val = random(100,255); // genera un nmero aleatorio entre 100 y 255 que asigna a la variable val analogWrite(ledPin, val); // enva ese valor a la salida pin 9 delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo asigna a la variable de temporizacin delay(delayval); milisegundos } // espera un tiempo delayval medido en

Practica 13
Monitor de Nivel

Se trata de construir u indicador de nivel que sea capaz de medir el valor de una seal de entrada generada por un potencimetro desde una entrada analgica. Usaremos 3 diodos LEDs conectados a las salidas 6, 7 y 8 (no olvide conectar resistencias de 220 a cada LED). La entrada la conectaremos en la entrada analgica PIN 1 (analog IN1).

pg. 42

/* * Medidor de Nivel */ int ledPin1 = 8; // Seleccin de PIN para cada LED int ledPin2 = 7; int ledPin3 = 6; int inPin= 1; // selecciona la entrada analgica 1 (potencimetro) void turn_off() { //Apaga los 3 LEDS digitalWrite(ledPin1, LOW); digitalWrite(ledPin2, LOW); digitalWrite(ledPin3, LOW); } void setup() { pinMode(ledPin1, OUTPUT); // declara LEDs como salidas pinMode(ledPin2, OUTPUT); pinMode(ledPin3, OUTPUT); turn_off(); // } void loop(){ int val; val= analogRead(inPin); // lee el valor de la seal analgica turn_off();//apaga los tres LED // Si el valor de la seal medida es > 256 enciende LED del PIN8

pg. 43

if (val>= 256) digitalWrite(ledPin1, HIGH); // Si el valor de la seal medida es > 512 enciende LED del PIN7 if (val>= 512) digitalWrite(ledPin2, HIGH); // Si el valor de la seal medida es > 758 enciende LED del PIN6 if (val>= 768) digitalWrite(ledPin3, HIGH); }

Practica 14
Niveles de Iluminacin
Esta prctica pretende controlar el grado de iluminacin de una lmpara (simulada con un LED) mediante un pulsador. Si no pulsamos el pulsador (entrada 0) la lmpara incrementar y decrementar su brillo o nivel de iluminacin. Si pulsamos (entrada 1) la lmpara se encender y apagar con una cadencia de 50 ms.

/* Control de iluminacin mediante Pulsador */ int ledPin = 13; // Seleccin del PIN de salida Analgica int inputPin = 2; // Seleccin del PIN para la entrada de pulsador int val = 0; // variable para leer el estado del pulsador int fadeval = 0; void setup() { pinMode(ledPin, OUTPUT); // designacin de salida Analgica pinMode(inputPin, INPUT); // designacin de pulsador de entrada

pg. 44

} void loop() { val = digitalRead(inputPin); // leer valor de entrada if (val == HIGH) { // Botn pulsado digitalWrite(ledPin, LOW); // puesta a "0" de la salida delay(50); digitalWrite(ledPin, HIGH); // puesta a "1" de la salida delay(50); } else { // Si se presiona el boton for(fadeval = 0 ; fadeval <= 255; fadeval+=5) { // valor de salida analgicaasciende de min a max) analogWrite(ledPin, fadeval); // fija el valor en la salida ( desde 0-255) delay(100); } for(fadeval = 255; fadeval >=0; fadeval-=5) { // valor de salida analgica desciende(desde max to min) analogWrite(ledPin, fadeval); delay(100); } } }

Practica 15
Sensores Resistivos LDR-

pg. 45

Descripcin: Un LDR es una resistencia variable, que vara su valor dependiendo de la cantidad de luz que incide sobre su superficie. Cuanta ms intensidad de luz incide en la superficie de la LDR menor ser su resistencia y cuanta menos luz incide mayor ser la resistencia. Suelen ser utilizados como sensores de luz ambiental o como una fotoclula que activa un determinado proceso en ausencia o presencia de luz.

Vout=((Rbotton/(Rbottom+Rtop))*Vin Si la LDR es usada como Rtop, como en el primer circuito, da tensin alta (HIGH) en la salida cuando la LDR est en la luz, y una tensin baja (LOW) en la salida cuando la LDR est en la sombra. La accin del divisor de tensin es inversa cuando la LDR es usada como Rbottom en lugar de Rtop, como en el segundo circuito. El circuito da tensin Baja (LOW) en la salida cuando la LDR est en la luz, y una tensin alta (HIGH) en la salida cuando la LDR est en la sombra. El circuito divisor de tensin dar una tensin de la salida que cambia con la iluminacin, de forma inversamente proporcional a la cantidad de luz que reciba (sensor de oscuridad).

pg. 46

/* Sensor de Luz LDR * -----------------* * Enciende y apaga un LED (light emitting diode) conectado al pin digital #13. * La cantidad de tiempo que el LED estar encendido y apagado depende del * valor obtenido de analogRead(). * La salida del sensor de luz o divisor de tensin, est conectado * a la entrada del pin 3, por lo que * a ms luz, el parpadeo del LED ser menor y a menos luz el parpadeo del LED mayor. * (sensor de oscuridad) * * copyleft 2005 DojoDave <http://www.0j0.org> * http://arduino.berlios.de * */ int LightPin = 3; // selecciona el pin de entrada para el sensor de luz int ledPin = 13; // selecciona el pin para el LED int val = 0; // variable para almacenar el valor capturado desde el sensor void setup() { pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida } void loop() { val = analogRead(LightPin); //lee el valor del sensor digitalWrite(ledPin, HIGH); // enciende el LED delay(val); // detiene el programa por un tiempo digitalWrite(ledPin, LOW); // apaga el LED

pg. 47

delay(val); // detiene el programa por un tiempo }

Practica 16
Sensores Resistivos NTC-

En esta prctica mediremos la temperatura desde el PIN3 de entrada analgica y ver si este valor supera un valor dado de 500 (medida absoluta) si supera este valor activar la salida digital PIN13 y si no la apagara. Adems queremos que se muestre en el monitor de salida del IDE Arduino el valor ledo. Utilizaremos un sensor del tipo NTC. Un NTC o termistor NTC es una resistencia variable, que vara su valor dependiendo de la temperatura ambiente. Cuanta ms temperatura menor ser su resistencia y cuanto menos temperatura mayor ser la resistencia. Suelen ser utilizados en alarmas. Un sensor de temperatura se compone de un NTC como parte de un divisor de tensin resistivo. Ejemplo Como alarma de incendio o sensor de calor, utilizaremos un circuito que entregue una tensin alta cuando se detecten las condiciones de temperatura caliente. Necesitamos

pg. 48

poner un divisor de tensin con un termistor NTC en la posicin que ocupa Rarriba:

Como alarma de fro o sensor de fro, usaremos un circuito que d una tensin alta en condiciones fras. Necesitamos un divisor de voltaje con el termistor NTC en lugar de
R

bajo:

Materiales: 1.- NTC 1.- Resistencia 10k 2.- Diodo LED

//Detector de valor de temperatura int led=13; int motor=6; int ntc=3; int medida=0; //variable que guarda el lmite de temperatura al que se activa el ventilador

pg. 49

int nivel=500; void setup(){ pinMode(led,OUTPUT); pinMode(motor,OUTPUT); Serial.begin(9600); } //procedimiento que enva al puerto serie, para ser ledo en el monitor, void monitoriza(){ Serial.print(medida); //el valor de la seal de la NTC en la entrada analgica Serial.print(" "); delay(100); //para evitar saturar el puerto serie } void loop(){ medida=analogRead(ntc); monitoriza(); if(medida>nivel){ //si la seal del sensor supera el nivel marcado: digitalWrite(led,HIGH); //se enciende un aviso luminoso } else{ // si la seal est por debajo del nivel marcado digitalWrite(led,LOW); } }

pg. 50

Practica 17
Sensor de Fuerza

En esta prctica convertiremos un buzzer piezoelctrico en un sensor de presin o fuerza utilizando este como sensor de entrada en uno de los pines de entrada analgica de Arduino.

pg. 51

/* Sensor piezoelectrico * ----------* Convertir un zumbador piezoelectrico en un sensor de de fuerza * * Created 24 October 2006 * copyleft 2006 Tod E. Kurt <tod@todbot.com * http://todbot.com/ */ int ledPin = 13; int piezoPin = 2; int THRESHOLD = 1; // Configura valor mnimo para que se encienda la salida int val = 0; // variable que almacena el valor ledo por el sensor int t = 0; // valor del intervalo de medida void setup() { pinMode(ledPin, OUTPUT); Serial.begin(19200); Serial.println("ready"); // indicador de espera } void loop() { digitalWrite(ledPin,LOW); // indicador de reposo (esperando) val = analogRead(piezoPin); // lectura de valor del piezoelctrico if( val > THRESHOLD ) { // si el valor ledo es superior al mnimo establecido digitalWrite(ledPin, HIGH); // activa salida 13 t = 0; while(analogRead(piezoPin) > THRESHOLD) { t++; } // wait for it to go LOW (espera con una pequea histresis) if(t>100) { // escribe en el puerto Serial.print("knock! "); } } }

pg. 52

Practica 18
Generador de notas musicales

Se trata de generar hasta 8 notas musicales por una de las salidas analgicas de Arduino

PIN10Se debe crear un array (vector) de datos compuesto por los valores correspondientes a las 8 notas que se pretende sacar: int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};

pg. 53

Se deben definir tambin el tiempo de pausa entre nota y nota y el tiempo de pausa de fin de secuencia de notas: int tnota=100; int pausa=100; Las iteraciones para el recorrido de las 8 notas se realizan con una instruccin de tipo for: for(n=0;n<8;n++) El tiempo de activado y desactivado de la salida del zumbador tambin se resuelve con un bucle for: for(m=0;m<=tnota;m++){

pg. 54