manual practicas arduino-incompleto
TRANSCRIPT
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.
2012
pág. 1
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. 2
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. 3
¿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. 4
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. 5
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 arduino-
1.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. 6
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. 7
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. 8
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 Cantidad Prefijo Unidad S.I.
Voltaje de Operación (Vía USB) 5 -------- Volt
Voltaje de Entrada Recomendado (Vía entrada
de alimentación)
5 -12 -------- Volt
Voltaje Máximo (Vía USB) 6 --------- Volt
Voltaje Máximo (Vía entrada de alimentación) 20 Volt
Intensidad máxima en los pines de
Entrada/Salida
40 m A
Memoria Flash (UNO) 32 K b
Memoria Flash (LEONARDO) 32 K b
Velocidad de Reloj (Clock) 16 M Hz
pág. 9
PRACTICAS
1.- HOLA MUNDO
En informática, un programa “Hola Mundo” o “Hello World” es el que imprime el texto
<<Hola Mundo!>> 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
DESACTIVAR SALIDA
PIN 13
DELAY (1000 ms)
DELAY (1000 ms)
Practica 1
pág. 10
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); // Enciende el LED (El nivel de
voltaje es ALTO)
delay(1000); // espera un segundo
digitalWrite(led, LOW); // apaga el LED (El nivel de voltaje
es BAJO)
delay(1000); // espera un segundo
pág. 11
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. 12
pág. 13
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. 14
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. 15
// 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); // Apaga LED
digitalWrite(ledPin4, LOW); // 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. 16
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. 17
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. 18
/* 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, OUTPUT); // Inicializa el pin 13 como salida
digital
pinMode(inPin, INPUT); // Inicializa el pin 10 como entrada
digital
void loop()
valor = digitalRead(inPin); // Lee el valor de la entrada digital
digitalWrite(ledPin, valor); // Escribe el valor de la entrada
digital
pág. 19
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. 20
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. 21
pág. 22
/* 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://www.0j0.org>
* 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. 23
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. 24
/* 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. 25
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. 26
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. 27
pág. 28
/* 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++) // utilizando la secuencia de
control for(;;)
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. 29
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. 30
/* 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 a la placa Arduino. Puedes controlar la
velocidad a la que
* 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. 31
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 función 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);
pág. 32
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. 33
pág. 34
/* 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. 35
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. 36
pág. 37
/* 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. 38
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. 39
/* 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. 40
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. 41
Arduino SALIDAS PWM
UNO 3, 5, 6, 9, 10 y 11
LEONARDO 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 <[email protected]>
* http://todbot.com/
*
*/
int ledPin = 13; // selecciona el puerto consultando la tabla PWM
pág. 42
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); // espera un tiempo delayval medido en
milisegundos
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. 43
/*
* 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. 44
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. 45
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. 46
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. 47
/* 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://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
pág. 48
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. 49
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
Rbajo:
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. 50
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. 51
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. 52
/* Sensor piezoelectrico
* -----------
* Convertir un zumbador piezoelectrico en un sensor de de
fuerza
*
* Created 24 October 2006
* copyleft 2006 Tod E. Kurt <[email protected]
* http://todbot.com/
*/
int ledPin = 13;
int piezoPin = 2;
int THRESHOLD = 1; // Configura valor mínimo para que se
encienda la salida
int val = 0; // variable que almacena el valor leído 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
piezoeléctrico
if( val > 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. 53
Practica 18
Generador de notas musicales
Se trata de generar hasta 8 notas musicales por una de las salidas analógicas de
Arduino
–PIN10-
Se 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. 54
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++)