2012
Manual de Practicas Arduino Alejandro Campos Martínez – CONALEP Nayarit, Plantel Tepic 169 Esta guía lo llevara a conocer, dentro de un entorno básico, las capacidades de Arduino, de tal manera que comenzaremos desde la instalación hasta nuestros primeros proyectos basados en sistemas embebidos basados en Hardware Libre.
Contenido ¿Qué es Arduino? ............................................................................................................................. 3 ¿Porque usar Arduino? .................................................................................................................... 3 Definiciones ....................................................................................................................................... 4 Instalación ......................................................................................................................................... 5 Conecta la placa Arduino ............................................................................................................ 5 Instala los drivers ......................................................................................................................... 6 ARDUINO UNO ...................................................................................................................... 6 Configuración 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 Magnético (Reed switch) .......................................................................... 19 Practica 6 .......................................................................................................................................... 20 Lectura de Señales Analógicas ................................................................................................. 20 Practica 7 .......................................................................................................................................... 23 Secuenciales................................................................................................................................. 23 Auto Fantástico 1 .................................................................................................................... 23 AutoFantastico 2 ..................................................................................................................... 26 Practica 8 .......................................................................................................................................... 29 Estrella Fugaz .......................................................................................................................... 29
pág. 1
Practica 9 .......................................................................................................................................... 32 Contador ...................................................................................................................................... 32 Práctica 10 ........................................................................................................................................ 35 Contador 0 al 10 .......................................................................................................................... 35 Práctica 11 ........................................................................................................................................ 38 Entrada Analógica monitoreada por pc .................................................................................. 38 Practica 12 ........................................................................................................................................ 40 Vela ............................................................................................................................................... 40 Introducción a PWM .............................................................................................................. 40 Practica 13 ........................................................................................................................................ 42 Monitor de Nivel ........................................................................................................................ 42 Practica 14 ........................................................................................................................................ 44 Niveles de Iluminación .............................................................................................................. 44 Practica 15 ........................................................................................................................................ 45 Sensores Resistivos –LDR- ........................................................................................................ 45 Practica 16 ........................................................................................................................................ 48 Sensores Resistivos –NTC- ........................................................................................................ 48 Practica 17 ........................................................................................................................................ 51 Sensor de Fuerza......................................................................................................................... 51
pág. 2
¿Qué es Arduino? Arduino es una herramienta para hacer que las computadoras puedan sentir y controlar el mundo físico a través de tu computadora personal. Es una plataforma de desarrollo de computación física (physical computing) de código 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 computación física. 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 fáciles de usar. Arduino, además de simplificar el proceso de trabajar con microcontroladores, ofrece algunas ventajas respecto a otros sistemas a profesores y estudiantes:
Accesible - Las placas Arduino son más accesibles comparadas con otras plataformas de microcontroladores. La versión más cara de un módulo 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 mayoría de los entornos para microcontroladores están limitados a Windows.
Entorno de programación simple y directo - El entorno de programación de Arduino es fácil de usar para principiantes y lo suficientemente flexible para los usuarios avanzados.
Software ampliable y de código abierto- El software Arduino está publicado bajo una licencia libre y preparado para ser ampliado por programadores experimentados. El lenguaje puede ampliarse a través de librerías de C++, y si se está interesado en profundizar en los detalles técnicos, se puede dar el salto a la programación en el lenguaje AVR C en el que está basado. De igual modo se puede añadir directamente código en AVR C en tus programas si así lo deseas.
pág. 3
Hardware ampliable y de Código abierto - Arduino está basado en los microcontroladores ATMEGA168, ATMEGA328 y ATMEGA1280. Los diagramas esquemáticos de los módulos están publicados bajo licencia Creative Commons, por lo que diseñadores de circuitos con experiencia pueden hacer su propia versión del módulo, ampliándolo u optimizándolo. Incluso usuarios relativamente inexpertos pueden construir la versión para placa de desarrollo para entender cómo funciona y ahorrar algo de dinero.
Definiciones IDE Un IDE (sigla en inglés de integrated development environment) o Entorno de Desarrollo Integrado. Un IDE es un entorno de programación que ha sido empaquetado como un programa de aplicación, es decir, consiste en un editor de código, un compilador, un depurador y un constructor de interfaz gráfica (GUI). BOOT En informática, la secuencia de arranque, (boot o booting en inglés) es el proceso que inicia el sistema operativo cuando el usuario enciende una computadora. Se encarga de la inicialización del sistema y de los dispositivos. Boot Loader Un cargador de arranque ( "bootloader" en inglés) es un programa sencillo (que no tiene la totalidad de las funcionalidades de un sistema operativo) diseñado 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 pequeños 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 computación diseñado para realizar una o algunas pocas funciones dedicadas en un sistema de computación en tiempo real. Al contrario de lo que ocurre con los ordenadores de propósito general (como por ejemplo una computadora personal o PC) que están diseñados para cubrir un amplio rango de necesidades, los sistemas embebidos se diseñan para cubrir necesidades específicas. En un
pág. 4
sistema embebido la mayoría de los componentes se encuentran incluidos en la placa base (la tarjeta de vídeo, audio, módem, 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 podrían ser dispositivos como un taximetro, un sistema de control de acceso, la electrónica que controla una máquina expendedora o el sistema de control de una fotocopiadora entre otras múltiples aplicaciones. Por lo general los sistemas embebidos se pueden programar directamente en el lenguaje ensamblador del microcontrolador o microprocesador incorporado sobre el mismo, o también, utilizando los compiladores específicos, pueden utilizarse lenguajes como C o C++; en algunos casos, cuando el tiempo de respuesta de la aplicación no es un factor crítico, también pueden usarse lenguajes interpretados como JAVA. En el caso de Arduino la programación se hace con un lenguaje de programación llamado “Arduino”, el cual se encuentra basado en otro lenguaje de programación, “Wiring”.
Instalación Descarga la última versión del IDE de Arduino de la página de descargas: http://arduino.cc/en/Main/Software La última versión que se encuentra a la fecha de la edición de este documento es la 1.0.1, es la versión 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). Asegúrate de mantener la estructura de directorios. Haz doble click en la carpeta arduino1.0.1 para abrirla. Deberías 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 alimentación (nombrado como PWR en la placa) debería quedar encendido a partir de ese momento.
pág. 5
Instala los drivers
Cuando conectas la placa, Windows debería inicializar la instalación de los drivers (siempre y cuando no hayas utilizado esa computadora con una placa Arduino anteriormente). En Windows Vista y Windows 7, los drivers deberían descargarse e instalarse automáticamente.
En Windows XP, se abrirá el diálogo de instalación 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 localización específica (Avanzado) haz click en Siguiente.
Asegúrate que Buscar los mejores drivers en estas localizaciones esté seleccionado; deselecciona Buscar en medios removibles; selecciona Incluye esta localización en la búsqueda y navega al directorio drivers/FTDI USB Drivers dentro de la carpeta de Arduino que has descomprimido previamente. (La versión más reciente de los drivers se puede encontrar en la página web del fabricante del chip FTDI.) Haz click en Siguiente.
ARDUINO UNO El asistente de instalación 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 instalación de hardware volverá a iniciarse. Repite los mismos pasos que antes y selecciona la misma carpeta de instalación 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 sección de puertos; esa es tu placa Arduino.
pág. 6
Configuración del IDE Entra a la carpeta que descomprimiste, busca y ejecuta el archivo Arduino.exe
Una vez abierto el IDE de Arduino busca la pestaña “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.
pág. 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 máximo 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 comunicación USB. Los pines 0 y 1 pueden ser utilizados como puerto de comunicación serial, para poder enlazar algún Shield, Arduino o cualquier otro dispositivo que utilice protocolo de comunicación serial RS232. También tiene 6 entradas analógicas que proporcionan una resolución de 10 bits. Por defecto miden de 0 voltios (negativo) hasta 5 volts, aunque es posible cambiar el nivel más alto, utilizando el pin Aref y algún código de bajo nivel.
Especificaciones Generales de Arduino UNO y Leonardo
DESCRIPCIÓN Voltaje de Operación (Vía USB) Voltaje de Entrada Recomendado (Vía entrada de alimentación) Voltaje Máximo (Vía USB) Voltaje Máximo (Vía entrada de alimentación) Intensidad máxima en los pines de Entrada/Salida Memoria Flash (UNO) Memoria Flash (LEONARDO) Velocidad de Reloj (Clock)
pág. 8
Cantidad 5 5 -12
Prefijo ---------------
Unidad S.I. Volt Volt
6 20 40
--------m
Volt Volt A
32 32 16
K K M
b b Hz
PRACTICAS 1.- HOLA MUNDO En informática, un programa “Hola Mundo” o “Hello World” es el que imprime el texto <> en un dispositivo de visualización, sea monitor o pantalla. Se suele usar como introducción al estudio de un lenguaje de programación, siendo este el primer ejercicio típico y se considera como uno de los programas fundamentales desde el punto de vista didáctico. Visto en Arduino, nuestro “Hola Mundo” será un programa que logre encender y apagar un led en un tiempo determinado. Objetivo de la Práctica: 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
Configuración E/S SD PIN 13
ACTIVAR SALIDA PIN 13
DELAY (1000 ms)
DESACTIVAR SALIDA Practica 1
PIN 13
DELAY (1000 ms)
pág. 9
Código Fuente: /* Blink Enciende un LED por un segundo, luego lo apaga por otro segundo, y esto se repite siempre. Este ejemplo de código es de Dominio público */
// Como estamos usando el pin número 13 de la placa Arduino, creamos una variable de tipo entero y la llamamos led int led = 13;
//La función de configuración debe contenerla declaración de las variables. Es la primera función a ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para configura inicializar pinMode (modo de trabajo de las E/S), configuración de la comunicación en serie y otras. void setup() { // Inicializa la salida digital como una salida pinMode(led, OUTPUT); }
// La función loop repite la rutina por siempre: void loop() { digitalWrite(led, HIGH); voltaje es ALTO) delay(1000); digitalWrite(led, LOW); es BAJO) delay(1000); }
pág. 10
// Enciende el LED (El nivel de // espera un segundo // apaga el LED (El nivel de voltaje // espera un segundo
Practica 2 Alarma
Un sistema de alarma es un elemento de seguridad pasiva. Esto significa que no evitan una situación anormal, pero sí son capaces de advertir de ella, cumpliendo así, una función disuasoria frente a posibles problemas. Por ejemplo: La intrusión de personas. Inicio de fuego. El desbordamiento de un tanque. La presencia de agentes tóxicos. Cualquier situación que sea anormal para el usuario. Son capaces además de reducir el tiempo de ejecución de las acciones a tomar en función del problema presentado. Una vez que la alarma comienza a funcionar, o se activa dependiendo del sistema instalado, este puede tomar acciones en forma automática. Por ejemplo: Si se detecta la intrusión de una persona a un área determinada, mandar un mensaje telefónico a uno o varios números. Si se detecta la presencia de humo, calor o ambos, mandar un mensaje telefónico a uno o varios números o accionar la apertura de rociadores en el techo, para que apaguen el fuego. Si se detecta la presencia de agentes tóxicos 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.
pág. 11
pág. 12
Código 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 leído es “1” (botón presionado) digitalWrite(ledPin, LOW); // pone el LED en OFF } else{ digitalWrite(ledPin, LOW); // parpadea el LED delay(200); digitalWrite(ledPin, HIGH); delay(200); } }
pág. 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 diseño secuencial de LEDs,
el cual puede ser implementado hasta con catorce salidas.
pág. 14
// Encendido y apagado de 3 LEDs int ledPin1 = 10; // Define la salida de los LED´s int ledPin2 = 11; // Define la salida de los LED´s int ledPin3 = 12;
// Define la salida de los LED´s
int ledPin4 = 13;
// Define la salida de los LED´s
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);
// Apaga LED // Apaga LED
} 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 }
pág. 15
Practica 4 Interruptor
Un interruptor eléctrico es en su acepción más básica un dispositivo que permite desviar o interrumpir el curso de una corriente eléctrica. En electrónica se denomina pull-up a la acción de elevar la tensión de salida de un circuito lógico, a la tensión que, por lo general mediante un divisor de tensión, se pone a la entrada de un amplificador con el fin de desplazar su punto de trabajo, y se denomina pull-down a la acción inversa.
pág. 16
Implementaremos un sistema de control con interruptor básico, 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.
pág. 17
/* Pulsador * -------* * Detecta si el botón 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
OUTPUT); INPUT);
// //
Inicializa Inicializa
el el
pin pin
13 10
como como
salida entrada
} void loop() { valor = digitalRead(inPin); // Lee el valor de la entrada digital digitalWrite(ledPin, valor); // Escribe el valor de la entrada digital }
pág. 18
Practica 5 Lectura de Sensor Magnético (Reed switch)
El código de ejemplo es el mismo que se empleó para la práctica número 4, solo que aquí sustituiremos el interruptor por un sensor magnético (Reed Switch). Usamos arreglo resistivo pull-up conectamos el sensor al pin de entrada digital que leeremos cuando lo necesitemos. Cuando acerquemos un imán al sensor este se habilitara y con ello se activara el LED.
** Reed Switch: Catalogo Steren http://bit.ly/ScrCkk
pág. 19
Practica 6 Lectura de Señales Analógicas
Para esta práctica utilizaremos las entradas analógicas de Arduino, utilizando un potenciómetro que nos servirá para poder variar los valores de entrada. La resistencia variable es un dispositivo que tiene un contacto móvil que se mueve a lo largo de la superficie de una resistencia de valor total constante. Este contacto móvil 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.
pág. 20
pág. 21
/* Potenciómetro * -----------------* * 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://arduino.berlios.de * */ int potPin = 1; // seleccionar el pin de entrada analógico para el potenciómetro 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” }
pág. 22
Practica 7 Secuenciales Auto Fantástico 1
Este práctica se llama "El carro fantástico" en memoria de la serie de TV de los años 80 en la que el famoso David Hasselhoff tenía una máquina de IA (Inteligencia Artificial) conduciendo su Pontiac. El coche estaba equipado con gran cantidad de LED-s de todos los tamaños posibles que realizaban efectos parpadeantes. Esta práctica hace uso de 6 LED-s conectados a los PIN 2 a 7 de la placa mediante resistencias de 220 Ohmios. El primer código de ejemplo hace parpadear a los LED en secuencia de uno en uno, utilizando sólo 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 líneas de código. El tercer y último ejemplo se centra en el efecto visual de apagar y encender los LED-s de una forma más suave.
pág. 23
/* El coche fantástico 1 * --------------------* * Básicamente una extensión 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); // Configuración 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);
pág. 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);
pág. 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 práctica el efecto será el mismo que el anterior, solo que utilizaremos la sentencia for.
La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición.
Tambien usaremos un tipo de datos llamado Arrays.
Un array es un conjunto de
valores a los que se accede con un número índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice. El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0.
pág. 26
pág. 27
/* El coche fantástico 2 * Reduciendo las líneas de código 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
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); } }
pág. 28
de
Practica 8 Estrella Fugaz
Esta práctica simula el desplazamiento de una estrella fugaz a través de una línea de LEDs y la programación es muy similar a la del auto fantástico. El programa comienza encendiendo LED-s hasta que llegue al número 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 seguiría encendiendo LED hasta encenderlos todos. Esto ocurre cuando el tamaño de la cola es igual o mayor que el número de LED. El tamaño de la cola debería ser relativamente pequeño en comparación con el número de LED de forma que podamos ver la estrella.
pág. 29
/* Estrella fugaz * Este programa es una variante del ejemplo del coche fantástico. Muestra mediante * un loop una estrella fugaz que es dibujada en una línea 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". También * puedes controlar la longitud de la cola de la estrella a través de la variable "tail * length" * @author: Cristina Hoffmann */ // Variable declaración // Declaración 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 // Número de LED-s que permanecen encendidos antes de empezar a apagarlos para //formar la cola int tailLength = 4; // Número de LED-s conectados (que es también el tamaño del array) int lineSize = 11; void setup() // Configuración de los PIN-es como salida digital { int i; pinMode (controlLed, OUTPUT); for (i=0; i< lineSize; i++) { pinMode(pinArray[i], OUTPUT); } }
pág. 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 0) tailCounter--; } for (i=(lineSize-tailLength); i
pág. 31
Practica 9 Contador
Se trata de contar las veces que se pulsa un botón 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 número de impulsos generados se envía al PC para que se visualice en la pantalla.
pág. 32
pág. 33
/* Programa Contador * ----------* * Detecta si el botón conectado a la entrada 10 ha sido presionado y enciende el LED * Envía al PC el valor de la variable de cuenta ""Contador" vía 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 transmisión 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++;
pág. 34
Serial.println(contador); Serial.write(10); Serial.write(13); } } estadoanteriorboton = valor; }
Práctica 10 Contador 0 al 10
Esta práctica consiste en contar las veces que se pulsa un botón 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 número de impulsos generados se envía al PC para que se visualice en la pantalla.
pág. 35
pág. 36
/* Programa Contador de 0 a 10 * ----------* * Detecta si el botón conectado a la entrada 7 ha sido presionado y enciende el LED * Envía al PC el valor de la variable de cuenta ""Contador" vía 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 transmisión 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); pág. 37
Serial.write(10); Serial.write(13); if (contador==10) { // Limita la cuenta al valor 10 contador=0; } } } estadoanteriorboton = valor; }
Práctica 11 Entrada Analógica monitoreada por pc
En esta práctica configuraremos un canal de entrada analógico y enviar el valor leído al PC para visualizarlo por comunicación serial.
pág. 38
/* Entrada Analógica */ int potPin = 5; // selecciona el pin de entrada para colocar el potenciómetro int valor = 0; // variable para almacenar el valor leído por la entrada analógica void setup() { Serial.begin (9600); } void loop() { valor = analogRead(potPin); // lee el valor del canal de ENTRADA analógica Serial.println(valor); // Envía al PC el valor analógico leído y lo muestra en pantalla Serial.write(10); delay(100); }
pág. 39
Practica 12 Vela Introducción a PWM
La Modulación por Ancho de Pulso (PWM = Pulse Width Modulation) es una técnica para simular una salida analógica con una salida digital. El control digital se usa para crear una onda cuadrada, una señal que conmuta constantemente entre encendido y apagado. Este patrón de encendido-apagado puede simular voltajes entre 0 (siempre apagado) y 5 voltios (siempre encendido) simplemente variando la proporción de tiempo entre encendido y apagado. A la duración del tiempo de encendido (ON) se le llama Ancho de Pulso (pulse width). Para variar el valor analógico cambiamos, o modulamos, ese ancho de pulso. Si repetimos este patrón de encendido-apagado lo suficientemente rápido por ejemplo con un LED el resultado es como si la señal variara entre 0 y 5 voltios controlando el brillo del LED. En el gráfico de abajo las líneas verdes representan un periodo regular. Esta duración o periodo es la inversa de la frecuencia del PWM. En otras palabras, con la Arduino la frecuencia PWM es bastante próxima a 500Hz lo que equivale a periodos de 2 milisegundos cada uno. La llamada a la función 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 más específica sobre PWM en Arduino: http://arduino.cc/es/Tutorial/SecretsOfArduinoPWM
pág. 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 * http://todbot.com/ * */ int ledPin = 13; // selecciona el puerto consultando la tabla PWM
pág. 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 números aleatorios pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9 } void loop() { val = random(100,255); // genera un número aleatorio entre 100 y 255 que asigna a la variable val analogWrite(ledPin, val); // envía 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 temporización 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 señal de entrada generada por un potenciómetro desde una entrada analógica. 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 analógica PIN 1 (analog IN1).
pág. 42
/* * Medidor de Nivel */ int ledPin1 = 8; // Selección de PIN para cada LED int ledPin2 = 7; int ledPin3 = 6; int inPin= 1; // selecciona la entrada analógica 1 (potenciómetro) 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 señal analógica turn_off();//apaga los tres LED // Si el valor de la señal medida es > 256 enciende LED del PIN8
pág. 43
if (val>= 256) digitalWrite(ledPin1, HIGH); // Si el valor de la señal medida es > 512 enciende LED del PIN7 if (val>= 512) digitalWrite(ledPin2, HIGH); // Si el valor de la señal medida es > 758 enciende LED del PIN6 if (val>= 768) digitalWrite(ledPin3, HIGH); }
Practica 14 Niveles de Iluminación Esta práctica pretende controlar el grado de iluminación de una lámpara (simulada con un LED) mediante un pulsador. Si no pulsamos el pulsador (entrada 0) la lámpara incrementar y decrementar su brillo o nivel de iluminación. Si pulsamos (entrada 1) la lámpara se encenderá y apagará con una cadencia de 50 ms.
/* Control de iluminación mediante Pulsador */ int ledPin = 13; // Selección del PIN de salida Analógica int inputPin = 2; // Selección 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); // designación de salida Analógica pinMode(inputPin, INPUT); // designación de pulsador de entrada
pág. 44
} void loop() { val = digitalRead(inputPin); // leer valor de entrada if (val == HIGH) { // Botón 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 analógicaasciende 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 analógica desciende(desde max to min) analogWrite(ledPin, fadeval); delay(100); } } }
Practica 15 Sensores Resistivos –LDR-
pág. 45
Descripción: Un LDR es una resistencia variable, que varía su valor dependiendo de la cantidad de luz que incide sobre su superficie. Cuanta más 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 fotocélula 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 tensión alta (HIGH) en la salida cuando la LDR está en la luz, y una tensión baja (LOW) en la salida cuando la LDR está en la sombra. La acción del divisor de tensión es inversa cuando la LDR es usada como Rbottom en lugar de Rtop, como en el segundo circuito. El circuito da tensión Baja (LOW) en la salida cuando la LDR está en la luz, y una tensión alta (HIGH) en la salida cuando la LDR está en la sombra. El circuito divisor de tensión dará una tensión de la salida que cambia con la iluminación, de forma inversamente proporcional a la cantidad de luz que reciba (sensor de oscuridad).
pág. 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 tensión, está conectado * a la entrada del pin 3, por lo que * a más luz, el parpadeo del LED será menor y a menos luz el parpadeo del LED mayor. * (sensor de oscuridad) * * copyleft 2005 DojoDave * 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
pág. 47
delay(val); // detiene el programa por un tiempo }
Practica 16 Sensores Resistivos –NTC-
En esta práctica mediremos la temperatura desde el PIN3 de entrada analógica 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. Además queremos que se muestre en el monitor de salida del IDE Arduino el valor leído. Utilizaremos un sensor del tipo NTC. Un NTC o termistor NTC es una resistencia variable, que varía su valor dependiendo de la temperatura ambiente. Cuanta más 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 tensión resistivo. Ejemplo Como alarma de incendio o sensor de calor, utilizaremos un circuito que entregue una tensión alta cuando se detecten las condiciones de temperatura caliente. Necesitamos
pág. 48
poner un divisor de tensión con un termistor NTC en la posición que ocupa Rarriba:
Como alarma de frío o sensor de frío, usaremos un circuito que dé una tensión alta en condiciones frías. 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 límite de temperatura al que se activa el ventilador
pág. 49
int nivel=500; void setup(){ pinMode(led,OUTPUT); pinMode(motor,OUTPUT); Serial.begin(9600); } //procedimiento que envía al puerto serie, para ser leído en el monitor, void monitoriza(){ Serial.print(medida); //el valor de la señal de la NTC en la entrada analógica Serial.print(" "); delay(100); //para evitar saturar el puerto serie } void loop(){ medida=analogRead(ntc); monitoriza(); if(medida>nivel){ //si la señal del sensor supera el nivel marcado: digitalWrite(led,HIGH); //se enciende un aviso luminoso } else{ // si la señal está por debajo del nivel marcado digitalWrite(led,LOW); } }
pág. 50
Practica 17 Sensor de Fuerza
En esta práctica convertiremos un buzzer piezoeléctrico en un sensor de presión o fuerza utilizando este como sensor de entrada en uno de los pines de entrada analógica de Arduino.
pág. 51
/* Sensor piezoelectrico * ----------* Convertir un zumbador piezoelectrico en un sensor de de fuerza * * Created 24 October 2006 * copyleft 2006 Tod E. Kurt THRESHOLD ) { // si el valor leído es superior al mínimo establecido digitalWrite(ledPin, HIGH); // activa salida 13 t = 0; while(analogRead(piezoPin) > THRESHOLD) { t++; } // wait for it to go LOW (espera con una pequeña histéresis) if(t>100) { // escribe en el puerto Serial.print("knock! "); } } }
pág. 52
Practica 18 Generador de notas musicales
Se trata de generar hasta 8 notas musicales por una de las salidas analógicas 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};
pág. 53
Se deben definir también 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 instrucción de tipo for: for(n=0;n<8;n++) El tiempo de activado y desactivado de la salida del zumbador también se resuelve con un bucle for: for(m=0;m<=tnota;m++){
pág. 54
