Manual Practicas Arduino-Incompleto

2012

Manual de Practicas Arduino  Al ej an dr o Ca m p os Ma r tí ne z  –  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ó instalación n hasta nuestros primeros proyectos  basados en sistemas embebidos embebidos basados en Hardware Libre. 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

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 ( physical computing) 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. 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 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 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 e xperiencia 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, 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

Cantidad

Prefijo

Unidad S.I.

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)

5 5 -12

---------------

Volt Volt

6 20 40

--------m

Volt Volt A

32 32 16

K K M

b b Hz

pág. 8

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);

// Enciende el LED (El nivel de

voltaje es ALTO) delay(1000); digitalWrite(led, LOW);

// espera un segundo // apaga el LED (El nivel de voltaje

es BAJO) delay(1000); }

pág. 10

// 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= 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 =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  – NTCEn 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 e n 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