Información básica sobre Arduino - WordPress.comWidth Modulation) o proporcionan una onda cuadrada con un nivel alto (+5V) de “cierta” duración. Es muy útil para activar servomotores

PRÁCTICAS CON ARDUINO PARA 4ªESO.

http://www.practicasconarduino.com/manualrapido/prcticas_rpidas_para_el_aula.html

Información básica sobre Arduino

¿Qué es Arduino?

Arduino es una tarjeta electrónica que integra básicamente a un microcontrolador y un conjunto de pines de conexión de entradas y salidas que permiten, mediante un determinado programa, interaccionar con el medio físico mediante sensores y actuadores electrónicos. De esta forma podrás crear tus propios proyectos tecnológicos, dotarlos de sensores que detecten magnitudes físicas como luz, calor, fuerza, etc… y en base a esa información, escribiendo un programa, activar otros dispositivos (actuadores) como pequeñas bombillas, ledes, servomotores, pequeños motores DC, relés, etc… Los sensores se conectan a los pines de entrada y los actuadores a los de salida.

¿Qué es un microcontrolador?

Es un circuito integrado que se puede programar, o sea que puede ejecutar las órdenes que tenga almacenadas en su memoria. Tiene las tres funciones principals de un computador: la unidad central de proceso, memoria y entradas y salidas. Arduino utiliza la marca ATMEL, y el modelo de microcontrolador depende del tipo de tarjeta, por ejemplo la tarjeta Arduino Uno utiliza el micro ATMEL MEGA 328P.

¿Qué se puede hacer con Arduino, algún ejemplo?

Realmente el límite lo marca tu imaginación pero por dar alguna pista, podrías diseñar un sistema para la apertura y cierre de la puerta de un garaje, hacer un robot móvil que detecte objetos o que siga una línea negra, crear un detector de luz y oscuridad, implementar un termómetro, controlar un cilindro neumático, etc… En este manual tienes múltiples ejemplos de pequeños proyectos para el aula, aunque Arduino es una herramienta que también se utiliza en el ámbito profesional para monitorización de sensores y automatización a pequeña escala por su flexibilidad, fiabilidad y precio.

¿Qué son las entradas y salidas?

Mediante los conectores de Arduino correspondientes a las entradas y salidas podemos comunicar nuestros programas con el “mundo exterior”. Si queremos leer el valor de la magnitud física medida por un sensor, por ejemplo

http://www.practicasconarduino.com/manualrapido/prcticas_rpidas_para_el_aula.html

una LDR que detecta el nivel de luminosidad, lo tendremos que hacer conectando el sensor a uno de los pines de entrada (en este caso analógicas) de la tarjeta. De esta forma con una simple instrucción de lectura en el programa, podremos obtener el valor de la magnitud física. Si nuestra intención es actuar o “hacer algo” una vez leído el valor del sensor, por ejemplo encender un led si el sensor de luminosidad detecta oscuridad, tendremos que conectar el actuador (en este caso el led) a un pin de salida que proporcionará la corriente necesaria para activarlo. En Arduino las entradas pueden ser analógicas o digitales y las salidas sólo digitales. Cada pin digital tiene doble función entrada o salida. En la zona de configuración del programa hay que indicar explícitamente mediante una instrucción cuál es función desempeña un determinado pin.

¿Dónde se conectan los sensores a las entradas analógicas o digitales?

Los sensores utilizados en los proyectos que vamos a utilizar son de salida analógica, es decir proporcionan una variación de voltaje dentro de un rango (normalmente de 0 a +5V) dependiendo de lo que varíe la magnitud física medida. Muchos sensores son resistivos (luz, temperatura, humedad,…), es decir que varían su resistencia eléctrica con la magnitud física, pero mediante un sencillo montaje de divisor de tensión conseguimos una variación de voltaje apta para Arduino. Estos montajes los veremos en las prácticas del manual. Una vez realizadas las conexiones, si midiéramos la salida del sensor con un voltímetro nos daría un valor decimal, por ejemplo un nivel de luz “intermedio” (rango de 0 a 5V) de un sensor de luz podría dar 3,3 voltios. Este tipo de información el microcontrolador no la entiende tal cual, sólo es capaz de interpretar números binarios (“0” ó “1”) por lo que para traducir los valores analógicos dispone internamente de un conversor analógico – digital que hará la conversión entre los dos sistemas, de forma que podremos tener valores discretos de la medida de los sensores analógicos.

Entonces, ¿qué utilidad tienen las entradas digitales?

Las entradas digitales son útiles cuando las señales a leer son valores discretos. Por ejemplo queremos poner un pulsador o un interruptor que encienda un led. Hacemos un montaje que cuando se pulse, entren 5 voltios en el pin digital de entrada y cuando no se pulse que “entren” 0 voltios. De esta manera la lectura del pin digital de entrada será “HIGH” con 5 voltios o “LOW” con 0 voltios.

¿Qué son las salidas digitales etiquetadas con PWM (~)?

Son salidas digitales que simulan una salida analógica. Las siglas significan Modulación por Ancho de Pulso (Pulse Width Modulation) o proporcionan una onda cuadrada con un nivel alto (+5V) de “cierta” duración. Es muy útil para activar servomotores y llevarlos a una posición determinada o variar la luminosidad de un led. Lo puedes ver más explicado en la siguiente sección.

¿Puedo accionar motores DC con Arduino?

Si son motores muy pequeños sí sería posible aunque no es recomendable. Los motores necesitan un consumo alto de corriente, sobre todo si tienen que mover cierta carga, por lo que se recomienda o bien utilizar una tarjeta Shield o extensión de Arduino que dispone de circuitería apta para proporcionar dicha corriente (transistores). En este manual utilizamos una Shield bautizada como Edubásica de elaboración propia que dispone de un transistor y un circuito integrado LM293 para realizar esta función, además de otras ventajas para el aprendizaje de Arduino.

Hardware

Placa Arduino

Arduino puede tomar información del entorno a través de sus pines de entrada de toda una gama de

sensores y puede afectar aquello que le rodea controlando luces, motores y otros actuadores. El

microcontrolador en la placa Arduino se programa mediante el lenguaje de programación Arduino

(basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing).

Entradas y salidas

La placa Arduino Duemilanove o UNO consta de:

14 entradas digitales configurables Entrada/Salidas que operan a 5 ó 0 voltios. 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 Width Modulation). Si se

conecta cualquier dispositivo a los pines 0 y 1, eso interferirá con la comunicación USB.

6 entradas analógicas con una resolución de 10 bits que proporcionan un número entero de 0 a 1023. Por

defecto miden de 0 voltios (masa) hasta 5 voltios.

Pines de la placa

Elementos con los que podemos interactuar: (tomando como ejemplo la placa USB). Empezando en el

sentido de las agujas del reloj desde el centro de la parte superior:

• Pin de referencia analógica (naranja).

• Señal de tierra digital (verde claro).

• Pines digitales 2-13 (verde).

• Pines digitales 0-1 / entrada y salida del puerto serie: TX/RX (azul) (estándar de comunicación serie IC2).

• Botón de reset (negro).

• Entrada del circuito del programador serie (marrón).

• Pines de entrada analógica 0-5 (azul oscuro).

• Pines de alimentación y tierra (naranja y naranja claro).

• Entrada de la fuente de alimentación externa (9-12V DC) – X1 (gris).

• Conmutación entre fuente de alimentación externa o alimentación a través del puerto USB – SV1. En las placas más reciente la conmutación de la alimentación se realiza con un MOSFET.

• Puerto USB (rojo).

Las placas: Arduino Diecimila, Arduino Duemilanove o UNO y Arduino Mega están basados en los

microcontroladores Atmega168, Atmega 328 y Atmega1280 respectivamente.

Las especificaciones de cada uno de los microcontroladores se exponen en la tabla siguiente:

SHIELDS para Arduino

Las llamadas Shields (escudos) para Arduino son tarjetas que añaden funciones a la placa Arduino.

Como se ha comentado antes, Arduino por sí sola no puede proporcionar la suficiente intensidad para alimentar motores, relés o electroválvulas. El límite de intensidad que proporciona cada una de las salidas digitales es de 40 mA. Para poder activar estos dispositivos tendremos que montar un circuito externo adicional con transistores o circuitos integrados específicos para motores, como es el caso del LM293, que entregan la intensidad suficiente. Para facilitarnos la tarea existen unas placas adaptadas a los pines de Arduino que se ensamblan directamente sobre ella a modo de "escudo" (de ahí su nombre, shileds) y nos permiten tener pines adicionales para alimentar las cargas que Arduino por sí solo no es capaz de mover.

Hay también otro tipo de "shields" que proporcionan funciones como conexión Ethernet, WIFI, XBee, GSM, Host USB, etc... Actualmente hay decenas de ellas en el mercado. Puedes encontrar una larga lista de ellas en http://playground.arduino.cc/Main/SimilarBoards#goShie

Algunos ejemplos:

http://playground.arduino.cc/Main/SimilarBoards#goShie

Alimentación eléctrica de Arduino

Uno de los aspectos claves para el buen funcionamiento de proyectos con Arduino que incluyan elementos que consuman una intensidad superior a 200 mA como motores, relés, electroválvulas, etc... es la alimentación eléctrica de la placa. Normalmente tenemos dos posibilidades para alimentar Arduino:

Mediante el cable USB conectado al ordenador:

• Cada pin proporciona 40 mA.

• El límite proporcionado por el USB es de 500 mA en total.

Utilizando una fuente de alimentación externa conectada al jack de Arduino (fuente de voltaje, adaptador de corriente, batería o portapilas) :

• El voltaje recomendado de la fuente externa está entre 9 y 12 V.

• La intensidad máxima que puede entregar Arduino a los actuadores que queramos controlar (servos, motores, relés,...) es de 1A, aunque una exposición prolongada a esta corriente puede estropear la placa. Lo recomendable son 800 mA.

• El pin serigrafiado con Vin proporciona directamente el voltaje de la fuente conectada al jack de Arduino (menos la caída de tensión del diodo de protección), desde ese pin podemos sacar un cable y alimentar a los actuadores que necesitemos. Por ejemplo, si alimentamos con una pila externa de 9 V conectada al jack, en el pin Vin tendremos aproximadamente 9 V (hay que restar la caída de tensión del diodo de protección). Además en los pines 5V y 3.3V dispondremos también de dichos voltajes aunque la fuente externa sea de 9V.

Si conectamos demasiada carga, la placa Arduino suele tener un comportamiento anómalo

pudiéndose se resetear el micro.

Conectando el positivo (+Vcc) de la fuente externa a Vin y el negativo a GND:

Podemos alimentar Arduino externamente si necesidad de conector Jack a través de Vin y GND el problema es que nos saltamos un diodo de protección que evita que se queme el circuito por un exceso de corriente.

CONCLUSIÓN:

• Si necesitamos hacer funcionar actuadores de bajo consumo (luces, zumbadores, etc...) podremos trabajar directamente con el USB conectado al ordenador.

• Si necesitamos mover cargas, excitar bobinas u otros elementos de mayor consumo lo recomendable es alimentar externamente Arduino desde el Jack con un rango de 9 a 12 V.

Entorno de programación

El entorno de desarrollo Arduino (IDE, Integrated development environment) está constituido por un editor de texto para escribir el código, un área de mensajes, una consola de texto, una barra de herramientas con botones para las funciones comunes, y una serie de menús. Permite la conexión, por USB, con el hardware de Arduino para cargar los programas y comunicarse con ellos.

Arduino utiliza para escribir el código fuente o programa de aplicación lo que denomina "sketch" (programa). Estos programas son escritos en el editor de texto. Existe la posibilidad de cortar/pegar y buscar/remplazar texto. En el área de mensajes se muestra información mientras se cargan los programas y también muestra errores. La consola muestra el texto de salida para el entorno de Arduino incluyendo los mensajes de error completos y otras informaciones. La barra de herramientas permite verificar el proceso de carga, creación, apertura y guardado de programas, y la monitorización serie:

Encontraremos otros comandos en los cinco menús: Archivo, Editar, Programa, Herramientas, Ayuda. Los menús son sensibles al contexto, lo que significa que estarán disponibles sólo los elementos relevantes para la tarea que esté realizando en ese momento.

¿Cómo se programa Arduino?

Las partes principales de un programa hecho en Arduino son: Bloque de inclusión de módulos y declaración de variables, bloque de configuración void setup() donde se indica el modo de funcionamiento de los pines (entrada y salida), comunicación serie, etc... y bloque de ejecución continua void loop(), en este bloque se incluyen las acciones que queremos que realice el programa. Se ejecutará línea a línea de forma secuencial y continua. Cuando llegue a la última instrucción incluída en la función loop() volverá a ejecutar la primera y continuará en un bucle infinito.

¿Arduino tiene que estar continuamente conectada a un ordenador?

Sólo es necesario que esté conectado al ordenador mediante el USB para cargar los programas o para visualizar en tiempo de ejecución datos del programa mediante la consola serie. El ordenador proporciona la energía eléctrica suficiente para que funcionen los programas, pero una vez cargado el programa en la memoria del microcontrolador de Arduino se puede desconectar del USB y alimentar a la tarjeta mediante una fuente externa mediante el jack de alimentación con un margen de (5 a 20 Voltios). El programa cargado en Arduino queda grabado permanentemente aunque cese el suministro eléctrico.

¿Qué voy a aprender con este manual?

Aprenderás a realizar pequeños proyectos y prácticas cuya base de control es la tarjeta Arduino y en algunos casos

la shield “Edubásica”. EDUBÁSICA es una tarjeta que se coloca sobre Arduino y lleva integrados muchos de los componentes básicos para realizar las prácticas de electrónica, y ciertos proyectos tecnológicos de una manera muy sencilla, aunque todas las prácticas se pueden implementar sin el uso de esta tarjeta. La idea del manual es integrar los contenidos del currículo en 4º de Enseñanza Secundaria Obligatoria (alumnos de 15-16 años) con diferentes proyectos para que el alumno consiga un aprendizaje significativo de la Tecnología.

Para una mayor información y manejo de la instalación del entorno de programación, lenguaje de programación y librerías se encuentra en la página web de la comunidad Arduino:

www.arduino.cc (portal en inglés, más actualizada).

www.arduino.es (portal en español).

http://www.arduino.es/

Montajes básicos con Arduino

Antes de empezar a realizar pequeños proyectos, vamos a dar un repaso a la plataforma Arduino, con las prácticas básicas que necesitarás para comprender los conceptos y avanzar en el libro .

Conexiones digitales

En este apartado aprenderemos el funcionamiento básico de las entradas y salidas digitales de la placa Arduino. Si observamos bien la placa, vemos que hay 13 pines digitales.

En este caso la señal digital no es más que un valor discreto de entre dos posibles, que si en rigor se asocian a tensiones, nosotros por sencillez los asociaremos a dos valores que serán ,apagado o encendido o lo que es lo mismo LOW ó HIGH.

Así si asignamos un 0 al pin digital 4, es lo mismo que decir que ese pin, o mejor dicho, lo que esté conectado a ese pin estará apagado si le asignamos un 1, estamos diciendo que estárá encendido.

Entonces, ¿Con los 13 pines digitales de Arduino , podríamos actuar para controlar 13 bombillas? . Si, aunque Arduino es aún más potente ya que aún podemos usar los 5 pines analógicos también como salidas digitales.

Veamos como.

Resistencias pull-up y pull-down

En los proyectos con dispositivos digitales, caso de la placa Arduino, reciben señales de entradas digitales del exterior. Estas señales externas sirven para activar o desactivar un circuito, recibir información del estado de un sensor,...

Las resistencias “pull-up” y “pull-down” son resistencias que se ponen en las entradas digitales para fijar un valor por defecto, nivel alto (“1”) o nivel bajo (“0”), cuando no se detecta ningún valor. Esto ocurre cuando la entrada no está conectada a nada.

En el caso de tener que conectar un interruptor a una entrada digital de Arduino necesitamos hacerlo a través de una resistencia de este tipo. Veamos un ejemplo:

La resistencia “pull-up” establece un nivel alto (1) en la entrada digital en el estado de reposo del circuito. Un circuito con una entrada “pull-up” sería el siguiente.

La resistencia “pull-down” establece un nivel bajo (0) en la entrada digital en el estado de reposo del circuito. Este tipo de circuito es el más empleado en las entradas digitales para evitar lecturas erróneas debido a ruidos externos y consumo de energía. La resistencia suele ser de 10 kΩ y el circuito con esta configuración sería el siguiente.

Un ejemplo de circuito “pull-down” lo tenemos en la placa EduBásica en el pin digital D2, preparado para configurarlo como entrada, tiene conectado un pulsador y una resistencia pull-down. El esquema del circuito es el siguiente

El funcionamiento de este circuito que está conectado al pin digital D2 como entrada es detectar si el pulsador está pulsado o no.

• Si el pulsador no está pulsado en Pin, que está conectado a D2, tenemos 0V por no pasar corriente entre el pin D2 y masa. Por tanto, corresponde a un nivel bajo o “0” lógico.

• Si el pulsador esta pulsado en el pin D2 tenemos 5V, que corresponde a un nivel alto o “1” lógico.

• Si en el anterior circuito no se pone la resistencia de 10KΩ y el pulsador está abierto con el propósito de tener un nivel bajo porque no hay tensión, puede ocurrir y de manera aleatoria que el pin D2 lea un nivel alto por alguna interferencia producida por motores eléctricos, bobinas de un relé u otro dispositivo de nuestro proyecto.

Montaje 1: LED parpadeante

Vamos a controlar el encendido y apagado de un led conectado al pin13 de Arduino.

¿Por qué el pin13 y no otro? Podríamos hacerlo con otro, pero el pin13 tiene asociado un led en la placa justo debajo de el y así nos evitamos tener que montar. Si pusiéramos un pin polarizado correctamente entre el pin13 y GND también funcionaría. El pin13 tiene también una resistencia que hace posible conectarle un led directamente, si hacemos el montaje con otro pin debemos añadir esta resistencia de 10Kohm entre el led y el pin.

void setup() {

// inicializamos el pin 13

// para que sea de salida

pinMode(13, OUTPUT);

}

// Definimos la rutina cíclica

void loop() {

digitalWrite(13, HIGH); // Encendemos el pin13

delay(1000); // esperamos 1 segundo

digitalWrite(13, LOW); // Apagamos el pin13

delay(1000); // esperamos 1 segundo

}

Todo lo que está entre las llaves de loop(), se ejecuta indefinidamente. Así vemos un efecto de led parpadeante

ya que si analizamos las líneas del código vemos que el proceso es:

- Encendemos.

- Esperamos un segundo.

- Apagamos.

- Esperamos un segundo.

¡Atrevámonos y cambiemos los tiempos de parada!

Montaje 2: Semáforo

Montaremos un semáforo con los tres leds de la EduBásica. La EduBásica es opcional y podemos montar el circuito correspondiente con una protoboard, pero EduBásica nos ahorra trabajo.

Necesitamos añadir una resistencia entre el pin y el led, para evitar que el led se funda. EduBásica ya lleva estas resistencias integradas por lo que podemos ir directamente al montaje.

Vamos a ver el efecto que queremos realizar:

00:00 00:12

Carga el programa de la página siguiente en Arduino y verás como actúa.

Aparece un nuevo comando: Serial.print.

Este comando nos manda un texto al puesto serial por el que nos comunicamos con Arduino. De esta manera podemos depurar un programa sabiendo siempre por que línea está.

Para que funcione debemos tener en cuenta que:

• Hay que inicializar Serial. Esto se hace poniendo Serial.begin(9600) dentro de la rutina de setup(). 9600 se refiere a la velocidad que se comunicará.

• Serial.print(“xxx”) escribe lo que ponemos entre comillas tal cual.

• Serial.print(x) escribe el valor que contenga la variable x.

• Serial.println() es similar a lo anterior pero después añade un salto de línea.

Para ver lo que nuestro Arduino nos comunica por Serial, abrimos el monitor Serial que tenemos en el programa Arduino

/* Semáforo Arduino

Leds conectados a pines 3, 4 y 5 */

int verde = 3;

int amarillo = 4;

int rojo = 5;

void setup()

{

pinMode(verde, OUTPUT);

pinMode(amarillo, OUTPUT);

pinMode(rojo, OUTPUT);

Serial.begin(9600); //inicializa la comunicación Serial

}

void loop()

{

Serial.println("Semaforo - Inicio"); //Escribe el texto

digitalWrite(verde, HIGH);

Serial.println("Semaforo - Verde"); //Escribe el texto

delay(30000);

digitalWrite(verde, LOW);

digitalWrite(amarillo, HIGH);

Serial.println("Semaforo - Amarillo"); //Escribe texto

delay(8000);

digitalWrite(amarillo, LOW);

digitalWrite(rojo, HIGH);

Serial.println("Semaforo - Rojo"); //Escribe el texto

delay(20000);

digitalWrite(rojo, LOW);

}

Montaje 3: Pulsador

Hasta ahora hemos visto como programar Arduino para que ejecute repetitivamente acciones, pero este actuaba

de manera autónoma y nosotros sólo podíamos observar. Pero podemos interactuar con Arduino, por ejemplo, realizando una acción cuando activamos un pulsador.

En este ejemplo, vamos a encender un led cuando actuamos sobre el pulsador. Por sencillez usaremos EduBásica. (también puedes hacer el montaje en una protoboard).

Vamos a verlo en acción:

El pin 2 corresponde al pulsador y el pin 3 al led verde, solo nos queda cargar el programa y probar. Aparece un comando nuevo “digitalRead(buttonPin)” . Retorna el valor del pin que se ha configurado como entrada y al igual que en el caso de los pines que se configuran como salida, puede tener dos valores HIGH y LOW.

Si es HIGH significa que este pin está unido a la señal de 5v, si es LOW significa que está unido a 0v.

En la siguiente sección resolveremos la duda lógica de ¿Qué ocurre si no está en 0v ni en 5v?

const int buttonPin = 2; // Pin del pulsador

const int ledPin = 3; // Pin del Led

void setup() {

// pin del led de salida:

pinMode(ledPin, OUTPUT);

// pin del pulsador de entrada

pinMode(buttonPin, INPUT);

}

void loop(){

// Si el valor del pin del pulsador es HIGH es que esta pulsado

if (digitalRead(buttonPin) == HIGH) {

// Se enciende el LED:

digitalWrite(ledPin, HIGH);

}

else {

// Se apaga el LED:

digitalWrite(ledPin, LOW);

}

}

Conexiones analógicas

Las entradas analógicas se utilizan para leer la información de la magnitud física que nos proporciona los sensores de temperatura, luz, distancia,... La tensión que leemos del sensor no la proporciona un circuito asociado a dicho sensor en un rango de valores de tensión continua entre 0V y 5V.

La placa de Arduino tiene 6 entradas analógicas marcados como “A0”, “A1”,..., “A5” que reciben los valores continuos en un rango de 0V a 5V, pero la placa Arduino trabaja sólo con valores digitales, por lo que es necesario una conversión del valor analógico leído a un valor digital. La conversión la realiza un circuito analógico/digital incorporado en la propia placa.

El conversor A/D de la placa tiene 6 canales con una resolución de 10 bits. Estos bits de resolución son los que marcan la precisión en la conversión de la señal analógica a digital, ya que cuantos más bits tenga más se aproxima al valor analógico leído. En el caso de la placa Arduino el rango de los valores analógicos es de 0 a 5 V y con los 10 bits de resolución se puede obtener de 0 a 1023 valores digitales y se corresponde cada valor binario a (5V/1024) 5 mV en el rango analógico.

En estas condiciones son suficientes para hacer muchos proyectos tecnológicos. En el caso de necesitar mayor resolución y como no podemos aumentar el número de bits de conversor A/D se puede variar el rango analógico utilizando el voltaje de referencia Vref.

Las entradas analógicas tienen también la posible utilización como pines de entrada-salida digitales, siendo su enumeración desde 14 al 19.

En este manual dedicamos un capítulo completo a analizar la forma en que Arduino lee magnitudes analógicas. Asimismo veremos numerosos montajes en los que se utilizan estos pines para lectura de sensores.

Un caso especial: Señales PWM

La señal PWM (Pulse Width Modulation, Modulación de Ancho de Pulso) es una señal que utiliza el microcontrolador para generar una señal continua sobre el proceso a controlar. Por ejemplo, la variación de la intensidad luminosa de un led, el control de velocidad de un motor de corriente continua,...

Para que un dispositivo digital, microcontrolador de la placa Arduino, genere una señal continua lo que hace es emitir una señal cuadrada con pulsos de frecuencia constante y tensión de 5V. A continuación, variando la duración activa del pulso (ciclo de trabajo) se obtiene a la salida una señal continua variable desde 0V a 5V.

Veamos gráficamente la señal PWM:

Los pines digitales de la placa Arduino que se utilizan como salida de señal PWM generan una señal cuadrada de frecuencia constante (490Hz), sobre esta señal periódica por programación podemos variar la duración del pulso como vemos en estos 3 casos:

• La duración del pulso es pequeña y la salida va a tener un valor medio de tensión bajo, próximo a 0V.

• La duración del pulso es casi la mitad del período de la señal, por tanto, la salida va a tener un valor medio de tensión próximo a 2,5V.

• La duración del pulso se aproxima al tiempo del período y el valor medio de tensión de salida se aproxima a 5V.

Control de la intensidad de iluminación de un LED

Como ejemplo práctico de la señal PWM vamos a realizar un control de iluminación sobre un diodo led. Los circuitos que vamos a utilizar en este proyecto se encuentran en la placa EduBásica, también se puede montar en una protoboard, estos son:

• El circuito formado por el potenciómetro conectado a la entrada analógica A0.

• El circuito conectado al pin digital D3, utilizado como salida PWM, de esta manera nos va a permitir variar la luminosidad del LED.

Vamos a ver una pequeña demostración:

00:00 00:07

Cargamos el programa ejemplo, en la placa Arduino y teniendo acoplada la placa EduBásica o montados los circuitos en una placa protoboard, podemos ver su funcionamiento.

Para ver su funcionamiento activamos el monitor serie del IDE de programación y variamos el potenciómetro. El resultado es una variación de luminosidad y variación de valores en el monitor serie.

El siguiente gráfico es una pantalla del monitor serie con los valores leídos y el valor aplicado a la señal PWM para variar la luminosidad.

/*Lee la entrada analogica A0, mapea el resultado al rango de 0 a 255

y utiliza el resutado para poner la anchura del pulso PWM.

Tambien se escribe en el monitor serie el valor binario de A0 y

el valor mapeado para la señal PWM.

De esta manera controlamos la luminosidad del led verde

de la placa Edubasica

El circuito:

* potenciometro conectado a la entrada analogica A0.

Terminal central del potenciometro a pin A0.

Resto de terminales del potenciometro a +5V y masa

* Circuito de LED verde conectado a D3-PWM.

*/

// pines usados:

const int analogInPin = A0; // Entrada analogica A0 del potenciometro

const int analogOutPin = 3; // Salida PWM

int potValor = 0; // valor de lectura del potenciometro

int outputValor = 0; // valor de salida de la señal PWM

void setup() {

// inicializacion del monitor serie a 9600 bps:

Serial.begin(9600);

}

void loop() {

// lee el valor de la entrada analogica:

potValor = analogRead(analogInPin);

// mapea el rango para la señal de salida PWM:

outputValor = map(potValor, 0, 1023, 0, 255);

// asigna el valor cambiado a pin 3 PWM:

analogWrite(analogOutPin, outputValor);

// escribe el resultado en el monitor serie:

Serial.print("Potenciometro = " );

Serial.print(potValor);

Serial.print("\t PWM = ");

Serial.println(outputValor);

// espera 1 segundo cada bucle para una visualizacion aceptable

// conviene tener un valor aunque sea pequeño (10ms)

// por el proceso de conversion de A/D

delay(10);

}

Visualización de datos en la nube. Internet de las cosas.

Monitorizar los datos de temperatura y humedad obtenidos del sensor DHT11 en la nube. Para ello disponemos del portal web dweet.io que nos ofrece un servicio para enviar y representar datos en la nube sin necesidad, ni si quiera, de registrarnos en la plataforma. Vamos a ver los pasos a seguir:

1. Probamos la plataforma introduciendo un dato, para ello en el navegador tecleamos por ejemplo (cambia jorgeroden por tu nombre): http://dweet.io/dweet/for/jorgeroden?temperatura=20

2. Abre otra pestaña del navegador o utiliza un móvil para seguir el dato: http://dweet.io/follow/jorgeroden 3. Prueba añadiendo otra variable, en este caso la

humedad:http://dweet.io/dweet/for/jorgeroden?temperatura=20&humedad=8 Automatizamos el proceso de recogida de datos desde Arduino con un programa en Processing, que enviará datos a través del navegador a dweet.io. IMPORTANTE: No hay que tener abierto el monitor serie del IDE de Arduino porque ocupa el puerto y, por lo tanto, no deja leer los datos a Processing.

PROGRAMA A CARGAR EN ARDUINO:

#include "DHT.h"

#define DHTPIN 2

#define DHTTYPE DHT11 // DHT 11

DHT dht(DHTPIN, DHTTYPE);

void setup() {

Serial.begin(9600);

dht.begin();

}

void loop() {

delay(2000);

float h = dht.readHumidity();

float t = dht.readTemperature();

if (isnan(h) || isnan(t)) {

Serial.println("Fallo al leer el sensor DHT11");

http://dweet.io/dweet/for/jorgeroden?temperatura=20

http://dweet.io/follow/jorgeroden

http://dweet.io/dweet/for/jorgeroden?temperatura=20&humedad=8

return;

}

// Únicamente enviar a Processing las variables t y h

Serial.print("Temperatura=");

Serial.print(t);

Serial.print("Humedad=");

Serial.println(h);

}

PROGRAMA A EJECUTAR EN PROCESSING (PC / LAPTOP):

import processing.serial.*;

//lf es el caracter de retorno de carro, que en ASCII es 10

int lf = 10;

// El puerto serie

Serial myPort;

void setup() {

// Lista todos los puertos serie

println(Serial.list());

// OJO: Elige el puerto donde tengas conectado Arduino.

// Cambia el "0" de Serial.list()[0] por el orden que

// tu puerto ocupe en la lista (0, 1, 2,...).

// Si no lo tienes claro qué puerto ocupa Arduino mira

// en el IDE Arduino en "Herramientas" mira el puerto que esté seleccionado.

//Fíjate que tenemos la velocidad del puerto a la misma que pusimos en Arduino

myPort = new Serial(this, Serial.list()[0], 9600);

}

void draw() {

while (myPort.available() > 0) {

String lectura = myPort.readStringUntil(lf);

if (lectura != null) {

println(lectura);

//IMPORTANTE! cambia jorgeroden por tu nombre o lo que utilizases

anteriormente

loadStrings("https://dweet.io/dweet/for/jorgeroden?"+lectura);

}

}

}

REPRESENTACIÓN DE DATOS EN EL NAVEGADOR: Dweet.io nos ofrecerá los datos de la siguiente manera:

Si queremos algo más vistoso podemos utilizar el servicio freeboard.io aunque en este caso nos tendremos que registrar en la web. Una vez registrados podemos crear paneles indicadores configurados a nuestro gusto para visualizar la información. Primero habrá que añadir como fuente de datos Dweet.io y nuestro nombre utilizado allí (jorgeroden en el ejemplo). Después creamos un panel indicando que la fuente de datos que queremos utilizar y la variable en cuestión a visualizar.

¡Y resultado puede ser de este tipo!

http://www.practicasconarduino.com/manualrapido/freeboard.io

Uso de los servomotores.

Realizar un montaje que active un servomotor y modifique la posición de su eje cíclicamente desde 0, 90 y 180 grados con una parada en cada posición de 0,5 segundos . Un servo es un tipo especial de motor que puede posicionar su eje en un ángulo determinado entre 0 a 180 grados. Para ello dispone de una lógica electrónica interna que permite un control mucho más preciso que un motor de corriente continua (motor DC). Asimismo tiene un tope mecánico que hace que no pueda avanzar más de 180

grados. Para accionarlos con Arduino utilizamos los pines digitales marcados con PWM (~). PWM significa Modulación por ancho de impulsos (Pulse Width Modulation). Se trata de obtener una onda cuadrada donde, cuanto más tiempo esté el pulso en alto, más se asemejará a una señal analógica de 5V. Se usa el comando analogWrite(pin, valor) Donde valor está entre 0 y 255 según el ciclo de trabajo de la gráfica:

ESQUEMA:

ARDUINO SERVO

5V + (ROJO)

GND - (MARRÓN)

D9 (Para este ejemplo) SEÑAL (AMARILLO)

PROGRAMA:

#include <Servo.h>

Servo myservo; // crea un objeto tipo servo para controlar el servo

void setup(){

myservo.attach(9); //conecta al pin 9

}

void loop()

{

myservo.write(0);

delay(500);

myservo.write(90);

delay(500);

myservo.write(180);

delay(500);

}

Servos de rotación continua.

Realizar una práctica que haga girar un motor de rotación continua una vez con la siguiente secuencia: giro durante 2 segundos, parada durante 2 segundos y giro en sentido contrario durante 2 segundos. Un servomotor de rotación se programa de forma muy similar a los servomotores vistos anteriormente. La diferencia respecto a estos es que el servo de rotación continua puede girar (como su nombre indica) los 360 grados de forma continua. Hay que recordar que un servomotor sólo podía girar de 0 a 180 grados. Los servos de rotación continua llevan una reductora y proporcionan un buen par motor. Incluyen un circuito interno de control y las conexiones se realizan a través de 3 cables: Alimentación (+Vcc), Tierra (GND) y señal de control.

ESQUEMA:

PROGRAMA:

#include <Servo.h>

Servo servoRotCont; // crea los objetos para controlar los servomotores

void setup() {

servoRotCont.attach(9);

servoRotCont.write(0);//clockwise

delay(2000);

servoRotCont.write(90); //stop (el valor 90 depende del motor.

//Es conveniente probar valores por encima o por debajo

//de 90 hasta comprobar que se para el servomotor.

delay(2000);

servoRotCont.write(180);//counter-clockwise

delay(2000);

servoRotCont.write(90); //stop

}

void loop() {

}

Control de motores DC

Arduino (UNO) no proporciona corriente suficiente para hacer funcionar, en condiciones "dignas", un motor de corriente continua de los que solemos usar en el aula-taller de Tecnologías (motor DC). Conviene alimentar Arduino con una fuente externa (7 -12 V) para poder proporcionar intensidad necesaria para el par motor requerido en los proyectos. Para más información de cómo hacerlo se recomienda consultar el apartado (Alimentación eléctrica de Arduino). Existen "shields" o tarjetas que se encajan sobre Arduino y le añaden funciones específicas como mover motores DC.

Para obtener más información sobre estas placas se puede consultar la web oficial de Arduino: http://www.arduino.cc/en/Main/ArduinoMotorShieldR3

Además de utilizar una shield específica de motores DC, tenemos otras posibilidades para ponerlo en marcha:

• Montaje con transistor. • Conexión con circuito integrado L293

• Shield Edubásica.

Montaje con transistor Desde Arduino (salida digital) actuamos sobre la base si enviamos un HIGH al pin digital donde la conectemos (pin 6 en el esquema). El transistor tiene que tener suficiente ganancia. Se conecta un diodo de protección en antiparalelo (1N004). Cuando el motor se para las bobinas se desmagnetizan y se descargan de energía eléctrica. El diodo proporciona un camino para su descarga (la energía se disipa en forma de calor en el diodo) y así se evita que sufra el transistor. Otra posibilidad que protege el transistor es, en vez de conectar directamente el motor al colector del transistor, ubicar un relé en esa posición y accionar el motor con alimentación independiente con la conmutación del relé. Este ejercicio se propone en la sección de actividades.

Ejemplo de montaje con TIP121 (NPN, par

Darlington *): * Datasheet: https://www.fairchildsemi.com/datasheets/TI/TIP120.pdf

Programa

// Activa y desactiva un

// motorDC conectado al pin6

// durante 2 segundos

#define motorDC 6

void setup() {

http://www.arduino.cc/en/Main/ArduinoMotorShieldR3

http://www.practicasconarduino.com/manualrapido/montaje_con_transistor.html

http://www.practicasconarduino.com/manualrapido/montaje_con_circuito_l293.html

http://www.practicasconarduino.com/manualrapido/accionamiento_con_edubsica.html

pinMode(motorDC, OUTPUT);

}

void loop() {

digitalWrite(motorDC, HIGH);

delay(2000);

digitalWrite(motorDC, HIGH);

delay(2000);

}

Actividad Diseña un montaje que active el motor DC mediante un relé conectado al colector del transistor.

Montaje con L293 El circuito integrado L293 permite controlar motoresDC de pequeña potencia. Para utilizarlo hay que hacer un montaje externo a Arduino, en una placa de pruebas, y alimentar a los motores a través de este circuito integrado. El CI L293 tiene las siguientes características:

• Se pueden controlar hasta 2 motores.

• Proporciona 1A a los motores (en total) y permite cambiar el sentido de giro.

• Utiliza un puente en H que funciona según se observa en las figuras (internamente utiliza transistores para conmutar*) :

Modos de operación para invertir el sentido de giro:

"H bridge operating" by Cyril BUTTAY - own work, made using inkscape. Licensed under CC BY-SA 3.0 via Wikimedia Commons. *Datasheet: http://www.me.umn.edu/courses/me2011/arduino/technotes/dcmotors/L293/l293.pdf Como vimos en la sección de Alimentación eléctrica de Arduino NO es recomendable alimentar Arduino, cuando se trabaja con elementos de "alto" consumo como pueden ser los motores DC, con el cable USB. Tenemos la posibilidad de proporcionar más (mili)amperios a través de la conexión jack de Arduino. En el pin Vin tendremos una salida del voltaje que apliquemos por el jack que servirá para alimentar a los motores a través del integrado mediante el pin 8 (VC ó Vcc2). Para ver los márgenes de voltaje de trabajo del CI consultar la hoja de datos del fabricante. Vamos a ver de qué manera se pueden activar los motores DC para hacer una secuencia sencilla de giro. Primero de todo vamos a ver cómo se conecta todo. Las conexiones del circuito integrado según podemos ver en la hoja de datos del fabricante son las siguientes:

https://commons.wikimedia.org/wiki/File:H_bridge_operating.svg#/media/File:H_bridge_operating.svg

http://creativecommons.org/licenses/by-sa/3.0/

http://creativecommons.org/licenses/by-sa/3.0/

http://commons.wikimedia.org/wiki/

Vcc2(VC), pin 8 del L293: El voltaje que se introduzca aquí alimentará a los

motores (Vin de Arduino).

Vcc1(VSS), pin 18 del L293: El voltaje que se introduzca aquí alimentará al propio

circuito integrado (+5V de Arduino).

Las conexiones del circuito con Arduino las podemos ver en el siguiente esquema:

Vamos a detallar la correspondencia entre pines de Arduino y del circuito L293 Para saber la orientación del sentido de giro disponemos de la siguiente tabla de verdad:

Programa El programa hace que el motor gire en un sentido durante 1 segundo, cambie de sentido y gire durante otro segundo. Esta secuencia la repite 5 veces y después el motor se para.

#define ENABLE 3

#define DIRB 4

#define DIRA 5

void setup() {

int i = 0;

pinMode(ENABLE,OUTPUT);

pinMode(DIRA,OUTPUT);

pinMode(DIRB,OUTPUT);

digitalWrite(ENABLE,HIGH);

for (i=0;i<5;i++) {

digitalWrite(DIRA,HIGH);

digitalWrite(DIRB,LOW);

delay(1000);

digitalWrite(DIRA,LOW);

digitalWrite(DIRB,HIGH);

delay(1000);

}

digitalWrite(ENABLE,LOW);

}

void loop(){

}

Pregunta Verdadero-Falso Con el CI L293 podemos activar también relés, bobinas y cualquier otro dispositivo que requiera una corriente considerable además de los motores DC

Verdadero Falso Para el L293: alimentando con un nivel ALTO el pin 1, un nivel BAJO el pin 2 y un nivel ALTO el pin 7 hacemos que el motor gire a favor de las agujas del reloj.

Verdadero Falso Con el CI L293 puedo accionar hasta 6 motores DC simultáneamente.

Verdadero Falso La instrucción digitalWrite(ENABLE,LOW); del programa anterior,hace parar al motor DC independientemente del resto de señales.

Verdadero Falso

Shield Edubásica Edubásica es una tarjeta diseñada para facilitar la tarea en el aula. Elimina gran parte de cableado y conexiones en la placa de pruebas lo que evita muchos errores en las prácticas. En esta placa disponemos de las dos opciones vistas anteriormente. Edubásica lleva montados, entre otros componentes, un circuito integrado L293 y un transistor. Por lo tanto podemos activar motores usando ambas opciones, aunque lo recomendable es utilizar el L293 que permite cambiar de sentido de giro y también regular la velocidad. Para esto último se actúa, con una señal PWM, sobre los dos pines de habilitación (dependiendo de la hoja de datos viene como ENABLE o CHIP INHIBIT) del circuito L293. Los pines de Arduino que pueden regular la velocidad por PWM correspondientes a esas patillas de habilitación del L293 serán: D10 para el motor A y D11 para el motor B.

Para hacer funcionar dos motores DC con Edubásica sólo tenemos que conectar, en las clemas indicadas (serigrafiados en la placa como Motor A y Motor B), los dos cables de cada motor. Según se observa en la imagen, tenemos 4 conexiones para los dos motores. Desde Arduino, y con la tabla de verdad del CI L293 indicada en la sección anterior, podemos regular el sentido de giro y velocidad de cada motor. Edubásica lleva un interruptor que permite tomar el voltaje de la salida Vin de Arduino (alimentación externa), necesaria para dar la corriente suficiente para accionar los motores. Cuando el piloto Vin está encendido significa que la alimentación de Edubásica viene de Vin de Arduino, o bien, se adquiere directamente de una fuente externa conectada a la clema Vin de Edubásica de la regleta de alimentación (en la imagen se corresponde con la regleta de la parte inferior). Conectando los dos terminales del motor a la clema del transistor de Edubásica, también podríamos hacerlo funcionar enviando un nivel HIGH al pin digital 6 de Arduino. Este pin (D6)

http://www.practicasconarduino.com/manualrapido/descripcin_y_esquemas2.html

está conectado directamente a la base del transistor de Edubásica. La desventaja respecto al CI L293 es que, en este caso, no podríamos cambiar el sentido de giro.

Vamos a ver dos programas de test distintos que hacen funcionar ambos motores (A y B) mediante el circuito L293 de Edubasica: MOTOR A

/*

Test del motor A controlado un puente en H

del C.I. L293D

Comprueba el funcionamiento del motor A

EL INTERRUPTOR DE CORRIENTE DE EDUBASICA

TIENE QUE ESTAR EN POSICION ON

Sketch Test for motorA controlled

by L239D H bridge (600mA)

THE POWER SWITCH PROVIDEED ON EDUBASICA

MUST TO BE ON

Manuel Hidalgo - LeoBot Julio 2014

Pablo Garcia - May 2015

*/

//Etiquetas de identificación de los pines

// labels for pins

//pines para controlar la direccion de giro

// with 2 pins we control de spinning direction

const int motorA_Dir1 = 8;

const int motorA_Dir2 = 9;

const int motorA_Velocidad = 10;

//salida PWM para controlar la velocidad

// PWM for speed

//Variables

int vPWM = 155; //valor de la velocidad en PWM

// PWM speed

void setup(){

//configuracion de los pines //pins setup

pinMode(motorA_Dir1, OUTPUT);

pinMode(motorA_Dir2, OUTPUT);

}

void loop(){

forward();

delay(4000);

stop();

delay(2000);

backw();

delay(4000);

stop();

delay(2000);

}

void forward(){

//Activamos el motor A en un sentido de giro

//spinning direction 1 (high-low)

digitalWrite(motorA_Dir1,HIGH);

digitalWrite(motorA_Dir2,LOW);

analogWrite(motorA_Velocidad,vPWM);

}

void backw(){

//Activamos el motor A en un sentido de giro

//spinning direction 1 (high-low)


digitalWrite(motorA_Dir2,HIGH);

analogWrite(motorA_Velocidad,vPWM);

}

void stop(){

//Paramos el motor durante 2s //stop for 2 secs

//STOP (low, low)



}

MOTOR B

/*

Test del motor B controlado un puente en H

del C.I. L293D

Comprueba el funcionamiento del motor B

Manuel Hidalgo - LeoBot

Julio 2014

*/

//Etiquetas de identificación de los pines

const int motorB_Dir1 = 12;

//pines para controlar la direccion de giro

const int motorB_Dir2 = 13;

const int motorB_Velocidad = 11;

//salida PWM para controlar la velocidad

//Variables

int vPWM = 155; //valor de la velocidad en PWM

void setup(){

//configuracion de los pines

pinMode(motorB_Dir1, OUTPUT);

pinMode(motorB_Dir2, OUTPUT);

}

void loop(){

//Activamos el motor B en un sentido de giro

digitalWrite(motorB_Dir1,HIGH);

digitalWrite(motorB_Dir2,LOW);

analogWrite(motorB_Velocidad,vPWM);

delay(5000); //permanece activado 5s

//Paramos el motor durante 2 segundo



delay(2000);

//Activamos el motor B en un sentido de giro


digitalWrite(motorB_Dir2,HIGH);

analogWrite(motorB_Velocidad,vPWM);

delay(5000); //permanece activado 5s

//Paramos el motor durante 1 segundo



delay(2000);

}

Acelerómetro y giroscopio (MPU 6065).

Realizar una montaje que utilice el acelerómetro/giroscopio MPU 6050 de tal manera que cuando lo giremos horizontalmente el eje de un servomotor siga el movimiento del sensor. Para ello conectaremos el servo al pin 10 y realizaremos las conexiones con Arduino del sensor MPU 6050 indicadas en la tabla indicada en la sección de Montaje.

También es necesario instalar la librería para MPU 6050 (desarrollo de Jeff Rowberg) disponible en internet. Un enlace para su descarga lo encontramos en http://diyhacking.com/projects/MPU6050.zip

Otra librería necesaria es I2Cdev: http://diyhacking.com/projects/I2Cdev.zip

Vamos a ver el resultado de la demostración en el siguiente vídeo:

ESQUEMA:

ARDUINO MPU 6050

5V VCC

GND GND

http://diyhacking.com/projects/MPU6050.zip

http://diyhacking.com/projects/I2Cdev.zip

A4 SDA

A5 SCL

D2 INT


// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class using

DMP (MotionApps v2.0)

// 6/21/2012 by Jeff Rowberg <[email protected]>

// Updates should (hopefully) always be available at

https://github.com/jrowberg/i2cdevlib

//

// Changelog:

// 2013-05-08 - added seamless Fastwire support

// - added note about gyro calibration

// 2012-06-21 - added note about Arduino 1.0.1 + Leonardo compatibility error

// 2012-06-20 - improved FIFO overflow handling and simplified read process

// 2012-06-19 - completely rearranged DMP initialization code and

simplification

// 2012-06-13 - pull gyro and accel data from FIFO packet instead of reading

directly

// 2012-06-09 - fix broken FIFO read sequence and change interrupt detection

to RISING

// 2012-06-05 - add gravity-compensated initial reference frame acceleration

output

// - add 3D math helper file to DMP6 example sketch

// - add Euler output and Yaw/Pitch/Roll output formats

// 2012-06-04 - remove accel offset clearing for better results (thanks Sungon

Lee)

// 2012-06-01 - fixed gyro sensitivity to be 2000 deg/sec instead of 250

// 2012-05-30 - basic DMP initialization working

/* ============================================

I2Cdev device library code is placed under the MIT license

Copyright (c) 2012 Jeff Rowberg

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

===============================================

*/

// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files

// for both classes must be in the include path of your project

#include "I2Cdev.h"

#include "MPU6050_6Axis_MotionApps20.h"

//#include "MPU6050.h" // not necessary if using MotionApps include file

// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation

ARDUINO SERVO

5V +Vcc

GND GND

D10 SEÑAL

// is used in I2Cdev.h

#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE

#include "Wire.h"

#endif

// class default I2C address is 0x68

// specific I2C addresses may be passed as a parameter here

// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)

// AD0 high = 0x69

MPU6050 mpu;

//MPU6050 mpu(0x69); // <-- use for AD0 high

/* =========================================================================

NOTE: In addition to connection 3.3v, GND, SDA, and SCL, this sketch

depends on the MPU-6050's INT pin being connected to the Arduino's

external interrupt #0 pin. On the Arduino Uno and Mega 2560, this is

digital I/O pin 2.

* ========================================================================= */

/* =========================================================================

NOTE: Arduino v1.0.1 with the Leonardo board generates a compile error

when using Serial.write(buf, len). The Teapot output uses this method.

The solution requires a modification to the Arduino USBAPI.h file, which

is fortunately simple, but annoying. This will be fixed in the next IDE

release. For more info, see these links:

http://arduino.cc/forum/index.php/topic,109987.0.html

http://code.google.com/p/arduino/issues/detail?id=958

* ========================================================================= */

// uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual

// quaternion components in a [w, x, y, z] format (not best for parsing

// on a remote host such as Processing or something though)

//#define OUTPUT_READABLE_QUATERNION

// uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles

// (in degrees) calculated from the quaternions coming from the FIFO.

// Note that Euler angles suffer from gimbal lock (for more info, see

// http://en.wikipedia.org/wiki/Gimbal_lock)

//#define OUTPUT_READABLE_EULER

// uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/

// pitch/roll angles (in degrees) calculated from the quaternions coming

// from the FIFO. Note this also requires gravity vector calculations.

// Also note that yaw/pitch/roll angles suffer from gimbal lock (for

// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock)

#define OUTPUT_READABLE_YAWPITCHROLL

// uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration

// components with gravity removed. This acceleration reference frame is

// not compensated for orientation, so +X is always +X according to the

// sensor, just without the effects of gravity. If you want acceleration

// compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead.

//#define OUTPUT_READABLE_REALACCEL

// uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration

// components with gravity removed and adjusted for the world frame of

// reference (yaw is relative to initial orientation, since no magnetometer

// is present in this case). Could be quite handy in some cases.

//#define OUTPUT_READABLE_WORLDACCEL

// uncomment "OUTPUT_TEAPOT" if you want output that matches the

// format used for the InvenSense teapot demo

//#define OUTPUT_TEAPOT

#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)

bool blinkState = false;

// MPU control/status vars

bool dmpReady = false; // set true if DMP init was successful

uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU

uint8_t devStatus; // return status after each device operation (0 = success,

!0 = error)

uint16_t packetSize; // expected DMP packet size (default is 42 bytes)

uint16_t fifoCount; // count of all bytes currently in FIFO

uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars

Quaternion q; // [w, x, y, z] quaternion container

VectorInt16 aa; // [x, y, z] accel sensor measurements

VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor

measurements

VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor

measurements

VectorFloat gravity; // [x, y, z] gravity vector

float euler[3]; // [psi, theta, phi] Euler angle container

float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and

gravity vector

// packet structure for InvenSense teapot demo

uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n'

};

// ================================================================

// === INTERRUPT DETECTION ROUTINE ===

// ================================================================

volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has

gone high

void dmpDataReady() {

mpuInterrupt = true;

}

#include "Servo.h"

Servo servo1;

// ================================================================

// === INITIAL SETUP ===

// ================================================================

void setup() {

// join I2C bus (I2Cdev library doesn't do this automatically)


Wire.begin();

TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)

#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE

Fastwire::setup(400, true);

#endif

// initialize serial communication

// (115200 chosen because it is required for Teapot Demo output, but it's

// really up to you depending on your project)

Serial.begin(115200);

while (!Serial); // wait for Leonardo enumeration, others continue immediately

// NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio

// Pro Mini running at 3.3v, cannot handle this baud rate reliably due to

// the baud timing being too misaligned with processor ticks. You must use

// 38400 or slower in these cases, or use some kind of external separate

// crystal solution for the UART timer.

// initialize device

Serial.println(F("Initializing I2C devices..."));

mpu.initialize();

// verify connection

Serial.println(F("Testing device connections..."));

Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") :

F("MPU6050 connection failed"));

// wait for ready

Serial.println(F("\nSend any character to begin DMP programming and demo: "));

while (Serial.available() && Serial.read()); // empty buffer

while (!Serial.available()); // wait for data

while (Serial.available() && Serial.read()); // empty buffer again

// load and configure the DMP

Serial.println(F("Initializing DMP..."));

devStatus = mpu.dmpInitialize();

// supply your own gyro offsets here, scaled for min sensitivity

mpu.setXGyroOffset(220);

mpu.setYGyroOffset(76);

mpu.setZGyroOffset(-85);

mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

// make sure it worked (returns 0 if so)

if (devStatus == 0) {

// turn on the DMP, now that it's ready

Serial.println(F("Enabling DMP..."));

mpu.setDMPEnabled(true);

// enable Arduino interrupt detection

Serial.println(F("Enabling interrupt detection (Arduino external interrupt

0)..."));

attachInterrupt(0, dmpDataReady, RISING);

mpuIntStatus = mpu.getIntStatus();

// set our DMP Ready flag so the main loop() function knows it's okay to

use it

Serial.println(F("DMP ready! Waiting for first interrupt..."));

dmpReady = true;

// get expected DMP packet size for later comparison

packetSize = mpu.dmpGetFIFOPacketSize();

} else {

// ERROR!

// 1 = initial memory load failed

// 2 = DMP configuration updates failed

// (if it's going to break, usually the code will be 1)

Serial.print(F("DMP Initialization failed (code "));

Serial.print(devStatus);

Serial.println(F(")"));

}

// configure LED for output

pinMode(LED_PIN, OUTPUT);

servo1.attach(10);

}

// ================================================================

// === MAIN PROGRAM LOOP ===

// ================================================================

void loop() {

// if programming failed, don't try to do anything

if (!dmpReady) return;

// wait for MPU interrupt or extra packet(s) available

while (!mpuInterrupt && fifoCount < packetSize) {

// other program behavior stuff here

// .

// .

// .

// if you are really paranoid you can frequently test in between other

// stuff to see if mpuInterrupt is true, and if so, "break;" from the

// while() loop to immediately process the MPU data

// .

// .

// .

}

// reset interrupt flag and get INT_STATUS byte

mpuInterrupt = false;


// get current FIFO count

fifoCount = mpu.getFIFOCount();

// check for overflow (this should never happen unless our code is too

inefficient)

if ((mpuIntStatus & 0x10) || fifoCount == 1024) {

// reset so we can continue cleanly

mpu.resetFIFO();

Serial.println(F("FIFO overflow!"));

// otherwise, check for DMP data ready interrupt (this should happen

frequently)

} else if (mpuIntStatus & 0x02) {

// wait for correct available data length, should be a VERY short wait

while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

// read a packet from FIFO

mpu.getFIFOBytes(fifoBuffer, packetSize);

// track FIFO count here in case there is > 1 packet available

// (this lets us immediately read more without waiting for an interrupt)

fifoCount -= packetSize;

#ifdef OUTPUT_READABLE_QUATERNION

// display quaternion values in easy matrix form: w x y z

mpu.dmpGetQuaternion(&q, fifoBuffer);

Serial.print("quat\t");

Serial.print(q.w);

Serial.print("\t");

Serial.print(q.x);

Serial.print("\t");

Serial.print(q.y);

Serial.print("\t");

Serial.println(q.z);

#endif

#ifdef OUTPUT_READABLE_EULER

// display Euler angles in degrees


mpu.dmpGetEuler(euler, &q);

Serial.print("euler\t");

Serial.print(euler[0] * 180/M_PI);

Serial.print("\t");


Serial.print("\t");

Serial.println(euler[2] * 180/M_PI);

#endif

#ifdef OUTPUT_READABLE_YAWPITCHROLL



mpu.dmpGetGravity(&gravity, &q);

mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);

Serial.print("ypr\t");

Serial.print(ypr[0] * 180/M_PI);

Serial.print("\t");


Serial.print("\t");

Serial.println(ypr[2] * 180/M_PI);

#endif

#ifdef OUTPUT_READABLE_REALACCEL

// display real acceleration, adjusted to remove gravity


mpu.dmpGetAccel(&aa, fifoBuffer);


mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);

Serial.print("areal\t");

Serial.print(aaReal.x);

Serial.print("\t");

Serial.print(aaReal.y);

Serial.print("\t");

Serial.println(aaReal.z);

#endif

#ifdef OUTPUT_READABLE_WORLDACCEL

// display initial world-frame acceleration, adjusted to remove gravity

// and rotated based on known orientation from quaternion





mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);

Serial.print("aworld\t");

Serial.print(aaWorld.x);

Serial.print("\t");

Serial.print(aaWorld.y);

Serial.print("\t");

Serial.println(aaWorld.z);

#endif

#ifdef OUTPUT_TEAPOT

// display quaternion values in InvenSense Teapot demo format:

teapotPacket[2] = fifoBuffer[0];








Serial.write(teapotPacket, 14);

teapotPacket[11]++; // packetCount, loops at 0xFF on purpose

#endif

// blink LED to indicate activity

blinkState = !blinkState;

digitalWrite(LED_PIN, blinkState);

servo_yaw();

}

}

void servo_yaw(){

if (ypr[0] > 0) servo1.write(ypr[0] * 180/M_PI);

}

Simulación con giroscopio (MPU 6050).

Realizar una simulación del movimiento del un modelo de avión en 3D, utilizando el módulo MPU 6050 que dispone de un acelerómetro y un giroscopio, mediante Arduino. El sensor enviará los datos por el puerto serie a un programa en Processing ejecutado en el ordenador, que orientará un modelo 3D básico de un avión según las coordenadas que reciba del sensor. La dificultad de esta práctica radica en la instalación de las librerías adicionales tanto en Processing como en Arduino. El código está implementado por Jeff Rowberg y está disponible en internet (se adjuntan los enlaces). Vamos a ver el resultado de la demostración en el siguiente vídeo: Preparación de la demo:

1. Instala la librería I2Cdev.zip y MPU6050.zip en Arduino 2. En Arduino carga el programa MPU6050_DMP6.ino

3. Processing: Instala toxiclibs-complete-0020.zip (Descomprime y pega en Sketchbook/libraries)

4. Processing: Ejecuta MPUTeapot.pde

Descargas: MPU6050_DMP6.ino, MPUTeapot.pde: https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

I2Cdev: https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/I2Cdev

ESQUEMA:

ARDUINO MPU 6050

5V VCC

GND GND

A4 SDA

A5 SCL

D2 INT

PROGRAMA A GARGAR EN ARDUINO:

// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class using

DMP (MotionApps v2.0)




//

http://hg.postspectacular.com/toxiclibs/downloads/

https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/I2Cdev

// Changelog:

// 2013-05-08 - added seamless Fastwire support

// - added note about gyro calibration

// 2012-06-21 - added note about Arduino 1.0.1 + Leonardo compatibility error

// 2012-06-20 - improved FIFO overflow handling and simplified read process

// 2012-06-19 - completely rearranged DMP initialization code and

simplification

// 2012-06-13 - pull gyro and accel data from FIFO packet instead of reading

directly

// 2012-06-09 - fix broken FIFO read sequence and change interrupt detection

to RISING

// 2012-06-05 - add gravity-compensated initial reference frame acceleration

output

// - add 3D math helper file to DMP6 example sketch

// - add Euler output and Yaw/Pitch/Roll output formats

// 2012-06-04 - remove accel offset clearing for better results (thanks Sungon

Lee)

// 2012-06-01 - fixed gyro sensitivity to be 2000 deg/sec instead of 250

// 2012-05-30 - basic DMP initialization working

/* ============================================

















THE SOFTWARE.

===============================================

*/

// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files

// for both classes must be in the include path of your project

#include "I2Cdev.h"

#include "MPU6050_6Axis_MotionApps20.h"

//#include "MPU6050.h" // not necessary if using MotionApps include file

// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation

// is used in I2Cdev.h


#include "Wire.h"

#endif

// class default I2C address is 0x68

// specific I2C addresses may be passed as a parameter here

// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)

// AD0 high = 0x69

MPU6050 mpu;

//MPU6050 mpu(0x69); // <-- use for AD0 high

/* =========================================================================

NOTE: In addition to connection 3.3v, GND, SDA, and SCL, this sketch

depends on the MPU-6050's INT pin being connected to the Arduino's

external interrupt #0 pin. On the Arduino Uno and Mega 2560, this is

digital I/O pin 2.

* ========================================================================= */

/* =========================================================================

NOTE: Arduino v1.0.1 with the Leonardo board generates a compile error

when using Serial.write(buf, len). The Teapot output uses this method.

The solution requires a modification to the Arduino USBAPI.h file, which

is fortunately simple, but annoying. This will be fixed in the next IDE

release. For more info, see these links:

http://arduino.cc/forum/index.php/topic,109987.0.html

http://code.google.com/p/arduino/issues/detail?id=958

* ========================================================================= */

// uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual

// quaternion components in a [w, x, y, z] format (not best for parsing

// on a remote host such as Processing or something though)

//#define OUTPUT_READABLE_QUATERNION

// uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles

// (in degrees) calculated from the quaternions coming from the FIFO.

// Note that Euler angles suffer from gimbal lock (for more info, see

// http://en.wikipedia.org/wiki/Gimbal_lock)

//#define OUTPUT_READABLE_EULER

// uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/

// pitch/roll angles (in degrees) calculated from the quaternions coming

// from the FIFO. Note this also requires gravity vector calculations.

// Also note that yaw/pitch/roll angles suffer from gimbal lock (for

// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock)

#define OUTPUT_READABLE_YAWPITCHROLL

// uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration

// components with gravity removed. This acceleration reference frame is

// not compensated for orientation, so +X is always +X according to the

// sensor, just without the effects of gravity. If you want acceleration

// compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead.

//#define OUTPUT_READABLE_REALACCEL

// uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration

// components with gravity removed and adjusted for the world frame of

// reference (yaw is relative to initial orientation, since no magnetometer

// is present in this case). Could be quite handy in some cases.

//#define OUTPUT_READABLE_WORLDACCEL

// uncomment "OUTPUT_TEAPOT" if you want output that matches the

// format used for the InvenSense teapot demo

#define OUTPUT_TEAPOT

#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)

bool blinkState = false;

// MPU control/status vars

bool dmpReady = false; // set true if DMP init was successful

uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU

uint8_t devStatus; // return status after each device operation (0 = success,

!0 = error)

uint16_t packetSize; // expected DMP packet size (default is 42 bytes)

uint16_t fifoCount; // count of all bytes currently in FIFO

uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars

Quaternion q; // [w, x, y, z] quaternion container

VectorInt16 aa; // [x, y, z] accel sensor measurements

VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor

measurements

VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor

measurements

VectorFloat gravity; // [x, y, z] gravity vector

float euler[3]; // [psi, theta, phi] Euler angle container

float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and

gravity vector

// packet structure for InvenSense teapot demo

uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n'

};

// ================================================================

// === INTERRUPT DETECTION ROUTINE ===

// ================================================================

volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has

gone high

void dmpDataReady() {

mpuInterrupt = true;

}

// ================================================================

// === INITIAL SETUP ===

// ================================================================

void setup() {

// join I2C bus (I2Cdev library doesn't do this automatically)


Wire.begin();

TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)

#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE

Fastwire::setup(400, true);

#endif

// initialize serial communication

// (115200 chosen because it is required for Teapot Demo output, but it's

// really up to you depending on your project)

Serial.begin(115200);

while (!Serial); // wait for Leonardo enumeration, others continue immediately

// NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio

// Pro Mini running at 3.3v, cannot handle this baud rate reliably due to

// the baud timing being too misaligned with processor ticks. You must use

// 38400 or slower in these cases, or use some kind of external separate

// crystal solution for the UART timer.

// initialize device

Serial.println(F("Initializing I2C devices..."));

mpu.initialize();

// verify connection

Serial.println(F("Testing device connections..."));

Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") :

F("MPU6050 connection failed"));

// wait for ready

Serial.println(F("\nSend any character to begin DMP programming and demo: "));

while (Serial.available() && Serial.read()); // empty buffer

while (!Serial.available()); // wait for data

while (Serial.available() && Serial.read()); // empty buffer again

// load and configure the DMP

Serial.println(F("Initializing DMP..."));

devStatus = mpu.dmpInitialize();

// supply your own gyro offsets here, scaled for min sensitivity

mpu.setXGyroOffset(220);

mpu.setYGyroOffset(76);

mpu.setZGyroOffset(-85);

mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

// make sure it worked (returns 0 if so)

if (devStatus == 0) {

// turn on the DMP, now that it's ready

Serial.println(F("Enabling DMP..."));

mpu.setDMPEnabled(true);

// enable Arduino interrupt detection

Serial.println(F("Enabling interrupt detection (Arduino external interrupt

0)..."));

attachInterrupt(0, dmpDataReady, RISING);


// set our DMP Ready flag so the main loop() function knows it's okay to

use it

Serial.println(F("DMP ready! Waiting for first interrupt..."));

dmpReady = true;

// get expected DMP packet size for later comparison

packetSize = mpu.dmpGetFIFOPacketSize();

} else {

// ERROR!

// 1 = initial memory load failed

// 2 = DMP configuration updates failed

// (if it's going to break, usually the code will be 1)

Serial.print(F("DMP Initialization failed (code "));

Serial.print(devStatus);

Serial.println(F(")"));

}

// configure LED for output

pinMode(LED_PIN, OUTPUT);

}

// ================================================================

// === MAIN PROGRAM LOOP ===

// ================================================================

void loop() {

// if programming failed, don't try to do anything

if (!dmpReady) return;

// wait for MPU interrupt or extra packet(s) available

while (!mpuInterrupt && fifoCount < packetSize) {

// other program behavior stuff here

// .

// .

// .

// if you are really paranoid you can frequently test in between other

// stuff to see if mpuInterrupt is true, and if so, "break;" from the

// while() loop to immediately process the MPU data

// .

// .

// .

}

// reset interrupt flag and get INT_STATUS byte

mpuInterrupt = false;


// get current FIFO count

fifoCount = mpu.getFIFOCount();

// check for overflow (this should never happen unless our code is too

inefficient)

if ((mpuIntStatus & 0x10) || fifoCount == 1024) {

// reset so we can continue cleanly

mpu.resetFIFO();

Serial.println(F("FIFO overflow!"));

// otherwise, check for DMP data ready interrupt (this should happen

frequently)

} else if (mpuIntStatus & 0x02) {

// wait for correct available data length, should be a VERY short wait

while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

// read a packet from FIFO

mpu.getFIFOBytes(fifoBuffer, packetSize);

// track FIFO count here in case there is > 1 packet available

// (this lets us immediately read more without waiting for an interrupt)

fifoCount -= packetSize;

#ifdef OUTPUT_READABLE_QUATERNION

// display quaternion values in easy matrix form: w x y z


Serial.print("quat\t");

Serial.print(q.w);

Serial.print("\t");

Serial.print(q.x);

Serial.print("\t");

Serial.print(q.y);

Serial.print("\t");

Serial.println(q.z);

#endif

#ifdef OUTPUT_READABLE_EULER



mpu.dmpGetEuler(euler, &q);

Serial.print("euler\t");


Serial.print("\t");


Serial.print("\t");

Serial.println(euler[2] * 180/M_PI);

#endif

#ifdef OUTPUT_READABLE_YAWPITCHROLL




mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);

Serial.print("ypr\t");


Serial.print("\t");


Serial.print("\t");

Serial.println(ypr[2] * 180/M_PI);

#endif

#ifdef OUTPUT_READABLE_REALACCEL

// display real acceleration, adjusted to remove gravity





Serial.print("areal\t");

Serial.print(aaReal.x);

Serial.print("\t");

Serial.print(aaReal.y);

Serial.print("\t");

Serial.println(aaReal.z);

#endif

#ifdef OUTPUT_READABLE_WORLDACCEL

// display initial world-frame acceleration, adjusted to remove gravity

// and rotated based on known orientation from quaternion





mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);

Serial.print("aworld\t");

Serial.print(aaWorld.x);

Serial.print("\t");

Serial.print(aaWorld.y);

Serial.print("\t");

Serial.println(aaWorld.z);

#endif

#ifdef OUTPUT_TEAPOT

// display quaternion values in InvenSense Teapot demo format:









Serial.write(teapotPacket, 14);

teapotPacket[11]++; // packetCount, loops at 0xFF on purpose

#endif

// blink LED to indicate activity

blinkState = !blinkState;

digitalWrite(LED_PIN, blinkState);

}

}

PROGRAMA A EJECUTAR EN PROCESSING (PC / LAPTOP):

// I2C device class (I2Cdev) demonstration Processing sketch for MPU6050 DMP output




//

// Changelog:

// 2012-06-20 - initial release

/* ============================================

















THE SOFTWARE.

===============================================

*/


import processing.opengl.*;

import toxi.geom.*;

import toxi.processing.*;

// NOTE: requires ToxicLibs to be installed in order to run properly.

// 1. Download from http://toxiclibs.org/downloads

// 2. Extract into [userdir]/Processing/libraries

// (location may be different on Mac/Linux)

// 3. Run and bask in awesomeness

ToxiclibsSupport gfx;

Serial port; // The serial port

char[] teapotPacket = new char[14]; // InvenSense Teapot packet

int serialCount = 0; // current packet byte position

int synced = 0;

int interval = 0;

float[] q = new float[4];

Quaternion quat = new Quaternion(1, 0, 0, 0);

float[] gravity = new float[3];

float[] euler = new float[3];

float[] ypr = new float[3];

void setup() {

// 300px square viewport using OpenGL rendering

size(300, 300, OPENGL);

gfx = new ToxiclibsSupport(this);

// setup lights and antialiasing

lights();

smooth();

// display serial port list for debugging/clarity

println(Serial.list());

// get the first available port (use EITHER this OR the specific port code

below)

String portName = Serial.list()[0];

// get a specific serial port (use EITHER this OR the first-available code

above)

//String portName = "COM4";

// open the serial port

port = new Serial(this, portName, 115200);

// send single character to trigger DMP init/start

// (expected by MPU6050_DMP6 example Arduino sketch)

port.write('r');

}

void draw() {

if (millis() - interval > 1000) {

// resend single character to trigger DMP init/start

// in case the MPU is halted/reset while applet is running

port.write('r');

interval = millis();

}

// black background

background(0);

// translate everything to the middle of the viewport

pushMatrix();

translate(width / 2, height / 2);

// 3-step rotation from yaw/pitch/roll angles (gimbal lock!)

// ...and other weirdness I haven't figured out yet

//rotateY(-ypr[0]);

//rotateZ(-ypr[1]);

//rotateX(-ypr[2]);

// toxiclibs direct angle/axis rotation from quaternion (NO gimbal lock!)

// (axis order [1, 3, 2] and inversion [-1, +1, +1] is a consequence of

// different coordinate system orientation assumptions between Processing

// and InvenSense DMP)

float[] axis = quat.toAxisAngle();

rotate(axis[0], -axis[1], axis[3], axis[2]);

// draw main body in red

fill(255, 0, 0, 200);

box(10, 10, 200);

// draw front-facing tip in blue

fill(0, 0, 255, 200);

pushMatrix();

translate(0, 0, -120);

rotateX(PI/2);

drawCylinder(0, 20, 20, 8);

popMatrix();

// draw wings and tail fin in green

fill(0, 255, 0, 200);

beginShape(TRIANGLES);

vertex(-100, 2, 30); vertex(0, 2, -80); vertex(100, 2, 30); // wing top

layer

vertex(-100, -2, 30); vertex(0, -2, -80); vertex(100, -2, 30); // wing bottom

layer

vertex(-2, 0, 98); vertex(-2, -30, 98); vertex(-2, 0, 70); // tail left layer

vertex( 2, 0, 98); vertex( 2, -30, 98); vertex( 2, 0, 70); // tail right layer

endShape();

beginShape(QUADS);

vertex(-100, 2, 30); vertex(-100, -2, 30); vertex( 0, -2, -80); vertex( 0, 2,

-80);

vertex( 100, 2, 30); vertex( 100, -2, 30); vertex( 0, -2, -80); vertex( 0, 2,

-80);

vertex(-100, 2, 30); vertex(-100, -2, 30); vertex(100, -2, 30); vertex(100, 2,

30);

vertex(-2, 0, 98); vertex(2, 0, 98); vertex(2, -30, 98); vertex(-2, -30,

98);

vertex(-2, 0, 98); vertex(2, 0, 98); vertex(2, 0, 70); vertex(-2, 0,

70);

vertex(-2, -30, 98); vertex(2, -30, 98); vertex(2, 0, 70); vertex(-2, 0,

70);

endShape();

popMatrix();

}

void serialEvent(Serial port) {

interval = millis();

while (port.available() > 0) {

int ch = port.read();

if (synced == 0 && ch != '$') return; // initial synchronization - also

used to resync/realign if needed

synced = 1;

print ((char)ch);

if ((serialCount == 1 && ch != 2)

|| (serialCount == 12 && ch != '\r')

|| (serialCount == 13 && ch != '\n')) {

serialCount = 0;

synced = 0;

return;

}

if (serialCount > 0 || ch == '$') {

teapotPacket[serialCount++] = (char)ch;

if (serialCount == 14) {

serialCount = 0; // restart packet byte position

// get quaternion from data packet

q[0] = ((teapotPacket[2] << 8) | teapotPacket[3]) / 16384.0f;




for (int i = 0; i < 4; i++) if (q[i] >= 2) q[i] = -4 + q[i];

// set our toxilibs quaternion to new data

quat.set(q[0], q[1], q[2], q[3]);

}

}

}

}

void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {

float angle = 0;

float angleIncrement = TWO_PI / sides;

beginShape(QUAD_STRIP);

for (int i = 0; i < sides + 1; ++i) {

vertex(topRadius*cos(angle), 0, topRadius*sin(angle));

vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));

angle += angleIncrement;

}

endShape();

// If it is not a cone, draw the circular top cap

if (topRadius != 0) {

angle = 0;

beginShape(TRIANGLE_FAN);

// Center point

vertex(0, 0, 0);

for (int i = 0; i < sides + 1; i++) {

vertex(topRadius * cos(angle), 0, topRadius * sin(angle));


}

endShape();

}

// If it is not a cone, draw the circular bottom cap

if (bottomRadius != 0) {

angle = 0;

beginShape(TRIANGLE_FAN);

// Center point

vertex(0, tall, 0);

for (int i = 0; i < sides + 1; i++) {

vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));


}

endShape();

}

}

Electrónica analógica

La electrónica es la ciencia que estudia y diseña dispositivos relacionados con el comportamiento de los electrones en la materia. En nuestro caso estudiaremos los componentes básicos utilizados en estos circuitos de bajo voltaje y usaremos Arduino, y la placa EduBásica, para practicar y entender mejor su funcionamiento.

Montaje 1: Interruptor La tarjeta Edubásica incorpora un pulsador que está internamente conectado al pin digital 2. De esta manera podemos leer el valor según el estado del pulsador:

• Pulsado = HIGH

• No Pulsado = LOW El esquema eléctrico de la conexión del pulsador es el que puedes ver en la figura.

Lo que vamos a hacer en este montaje es actuar sobre el estado de los ledes según activemos o no el pulsador. En el código siguiente puedes observar cómo vamos leyendo de la entrada digital 2. Si el interruptor NO está pulsado, el estado es LOW, y dejamos los 3 ledes apagados. Sin embargo, cuando lo pulsamos, la entrada digital 2 recibe 5V, su estado pasa a HIGH y entonces encenderemos los 3 ledes. Vamos a verlo:

00:00 00:06

// Indicamos que pin corresponde con cada LED:

int ledVerde = 5;

int ledAmarillo = 4;

int ledRojo = 3;

// El pulsador esta conectado al pin 2

int pulsa = 2;

// configuracion de pines

void setup() {

// los pines con leds son de salida

pinMode(ledVerde, OUTPUT);

pinMode(ledAmarillo, OUTPUT);

pinMode(ledRojo, OUTPUT);

pinMode(pulsa, INPUT); //pin de entrada

}

void loop() {

//Leemos del pin 2 para saber si se esta pulsando el boton

if (digitalRead(pulsa) == HIGH) //Si esta pulsado ENCENDEMOS

{

digitalWrite(ledVerde, HIGH);

digitalWrite(ledAmarillo, HIGH);

digitalWrite(ledRojo, HIGH);

}

else

{

digitalWrite(ledVerde, LOW);

digitalWrite(ledAmarillo, LOW);

digitalWrite(ledRojo, LOW);

}

}

Montaje 2: Potenciómetro Para este montaje utilizamos la tarjeta Edubásica. Lo primero que haremos será cargar un programa para comprobar que al variar el valor de una resistencia mediante un potenciómetro, también variará la cantidad de luz que emite un led. Como se puede ver en el siguiente vídeo, a medida que giramos el potenciómetro el led varía su luminosidad.

00:00 00:04

//Declaramos una variable para almacenar el valor recibido en pin 0.

int val = 0;

void setup() {

//El pin 3 corresponde al LED verde

pinMode(3, OUTPUT);

}

void loop() {

/*leemos el valor del pin O modificado por el potenciómetro que va desde 0 a 1023*/

val = analogRead(0);

/*Escribimos el valor obtenido en el LED verde que puede ser entre 0 y 255. Por eso

dividimos val por 4 */

analogWrite(3, val/4);

}

Mapeo de valores En ocasiones, los valores que obtenemos de una lectura de un pin, como un sensor, pueden estar fuera de una escala determinada, y tenemos que convertirlos a otro rango para poder usarlos. El valor de salida que podemos darle al led es de 0 a 255, que se traduce en su nivel de luminosidad, pero los datos que leemos del sensor pueden llegar a 1024. Por esto debemos mapear el resultado, es decir , dejarlo en unos valores de entre 0 y 255. La función “map” del programa asigna un valor máximo y un valor mínimo a un rango dado. El valor máximo suele estar en 1024, pero el mínimo dependerá de las condiciones de luz en las que realicemos la práctica. Por eso en el código se especifican 2 variables que deberemos colocar a mano: bajo_LDR y alto_LDR. Por ejemplo si hacemos una lectura previa de lo que nos devuelve el LDR y los valores mínimo y máximo son: 917, 1024 . La solución será mapear esos valores para que, en caso de obtener el valor 917 (el equivalente a cierta intensidad luminosa), el led verde se apague. Observa si tu montaje necesita de algún ajuste utilizando la función map.

Montaje 6: LDR con Edubasica En este montaje usaremos la resistencia LDR de la placa Edubásica. Como ya hemos comentado, la LDR modifica su resistencia en dependiendo de la cantidad de luz que incida sobre ella. El siguiente programa mostrará por consola (“Monitor Serial”) las variaciones de luminosidad que detecte la LDR simplemente pasando la mano por encima de ella.

//Detectamos la variación en la LDR

int luz;

void setup() {

// Pin 3 tiene el led verde

pinMode(3, OUTPUT);

Serial.begin(9600);

}

void loop() {

luz= map(analogRead(1), 917, 1024, 0, 255);

analogWrite(3,luz);

//escribimos el valor obtenido por la resistencia para ajustarlo

Serial.print("valor analogico leido=");

Serial.println(analogRead(1));

delay (1000);

}

Condensadores

Dos conductores cualesquiera separados por un aislante constituye un condensador. Este tipo de dispositivos eléctricos tienen gran variedad de usos como filtrar señales, eliminar ruido eléctrico o almacenar carga eléctrica entre otros. En casi todas las aplicaciones prácticas cada conductor se encuentra inicialmente descargado y al conectarlos a una batería, mediante transferencia de carga de la batería a los conductores, van adquiriendo una cierta carga (dicho proceso se denomina carga del condensador). En todo momento, ambos conductores tienen igual carga pero de signo opuesto de tal forma que entre ambos conductores existe un campo eléctrico y por tanto una diferencia de potencial que se opone a la externa responsable de su carga. El proceso de carga del condensador

se detiene cuando la diferencia de potencial entre los conductores del mismo se iguala a la de la batería. Hay que resaltar que aunque cada placa se encuentra cargada, la carga neta del condensador sigue siendo nula, puesto que la carga de cada conductor es igual a la del otro pero con signo contrario. Es por ello que cuando se dice que un conductor tiene una carga Q realmente lo que se está diciendo es que tiene una carga +Q en el conductor que se encuentra a mayor potencial y una carga – Q en el conductor a menor potencial (supuesto Q positiva). Montaje: Descarga de un condensador Haz el siguiente montaje sobre la protoboard. Como fuente de alimentación puedes usar los 5V que te ofrece la placa EduBasica a través de sus clemas.

Con el conmutador cerrado el condensador se carga, teniendo una tensión de 5V, y la lectura en la entrada A5 es de 5V y en el monitor serie de 1023. El led en esta situación está encendido. Al abrir el conmutador empieza el proceso de descarga del condensador a través del led y la resistencia. El tiempo de descarga es entre 3 y 5 veces la constante de tiempo (R·C, en segundos), en este caso entre 30 y 50 segundos. En el monitor serie podemos ver como disminuye el valor debido a la descarga del condensador y al mismo tiempo se observa que el diodo led se apaga. Carga el siguiente programa:

int sensorPin = A5;

int sensorValue = 0;

void setup() {

Serial.begin(9600);

}

void loop() {

sensorValue = analogRead(sensorPin);

Serial.println(sensorValue);

delay(100);

}

Montajes básicos: ALARMA EN VIVIENDA. Gracias a la lógica programable podemos programar alarmas muy complejas y mucho más eficientes que las alarmas convencionales. Las alarmas convencionales usan finales de carrera y, en definitiva, interruptores que activan una alarma. En nuestro caso vamos a dotar a la alarma de cierta lógica que nos proporcione mejores y más cómodos resultados. Las posibilidades son ilimitadas y depende de tu imaginación . En esta práctica y sólo como ejemplo vamos a suponer algunas cosas que, si bien no tienen por qué ajustarse a la realidad, si que sirven como ejemplo para mostrar y dar a entender las posibilidades de la alarma. puerta, encender la luz y cerrar la puerta. Partimos de las siguientes premisas :

1. El ladrón puede entrar sólo por la ventana o por la puerta. Fíjate en las puertas y ventanas de los comercios de tu localidad. Seguro que has visto más de uno.

2. Como la ventana de la casa da a una calle principal muy transitada el ladrón no intentará entrar nunca por la ventana cuando sea de día.

3. La entrada de nuestra casa es oscura y no tiene ventanas al exterior, por lo tanto nuestro comportamiento habitual es abrir la puerta, encender la luz y cerrar la puerta.

4. Sólo abrimos las ventanas de día, nunca por la noche.

Como detector de apertura de puerta y de ventana vamos a usar dos pulsadores, uno de la placa y otro que montaremos sobre la protoboard. Sabremos si es de día o de noche gracias al LDR de la EduBásica. Monta el pulsador sobre la protoboard y conéctalo entre 5V y la patilla digital 7. Usa para ello las clemas de la EduBásica tal y como muestra la imagen. Ten en cuenta que los interruptores podrían sustituirse en un caso real con relé un Reed conocido también como interruptor magnético. Son elementos económicos y de muy fácil instalación. Vamos a realizar la práctica en dos pasos para que lo puedas entender sin problemas. Primero carga este programa:

void setup() {

pinMode(7, INPUT); //Pin correspondiente al interruptor de la

PROTOBOARD

pinMode(2,INPUT); //Pin correspondiente al interruptor de la placa

Serial.begin(9600);

}

void loop() {

Serial.print( " VENTANA ");

Serial.print(digitalRead(7));//interruptor de la PROTOBOARD

Serial.print( " PUERTA ");

Serial.print(digitalRead(2)); //interruptor de la placa

Serial.print( " LUZ ");

Serial.println(analogRead(1)); //Nos muetra el valor del LDR

delay(1000); // wait for a second

Abre el “monitor serial” y prueba a activar los pulsadores. Verás que cuando están activos el valor obtenido es 1 y cuando están desactivados su valor es 0. Comprueba qué interruptor se corresponde con la ventana y cual con la puerta. Tapa ahora el LDR y observa el valor que obtienes cuando no recibe luz (será el mismo valor que si es de

noche). Atendiendo a los supuestos anteriores carga este programa y observa su funcionamiento. Si el led rojo se enciende es que la alarma se ha disparado.

int ventana, puerta, luz;//definimos variables

void setup() {

pinMode(7, INPUT);

pinMode(5,OUTPUT); //led rojo

pinMode(2,INPUT);

Serial.begin(9600);

}

void loop() {

ventana=digitalRead(7); //guardamos el estado de la ventana

Serial.print( " VENTANA ");

Serial.print(ventana);

puerta=digitalRead(2); //guardamos estado de puerta

Serial.print( " PUERTA ");

Serial.print(puerta);

luz=analogRead(1); //guardamos estado de LUZ

Serial.print( " LUZ ");

Serial.println(luz);

//implementamos la logica de la puerta

if (puerta==1) {//la puerta esta abierta

delay(3000); //esperamos hasta que encienda la luz

if (luz > 1000) {//no han encendido la luz

digitalWrite(5,HIGH); //Se activa la alarma

}

}

//implementamos logica de ventana

if (ventana==1 && luz < 1000){

digitalWrite(5,HIGH);

}

Actividad Como comprobarás una vez que la alarma se activa permanece en ese estado. Para desactivarla debes reiniciar la placa quitándole la alimentación. Piensa en una solución para poder desactivar la alarma, por ejemplo abriendo la ventana y la puerta a la vez. Actividad Ampliación: Usamos EduBásica porque dispone de elementos hardware ya instalados, como led y pulsador, pero piensa que sin EduBásica tu Arduino dispone de 13 entradas digitales y 6 analógicas. Piensa en un sistema más completo de alarma en el que puedas conectar sensores de humo o de movimiento (PIR).

Actividad Proyecto propuesto: Realiza todo el proceso para implementar, mediante funciones lógicas, el siguiente sistema: Se trata de una máquina de control de una cinta transportadora. Tenemos un sensor de temperatura basado en un termistor que nos dirá si se ha producido un sobrecalentamiento en la máquina. También hay un sensor de presión que detecta la presencia de un objeto sobre la cinta transportadora. Por último, la cinta transportadora sólo estará en funcionamiento si el operario mantiene apretado un pulsador. Tendremos un led que avisará si hay sobrecalientamiento y detendrá la cinta si está en movimiento. Un zumbador avisará cuando la cinta esté en movimiento.

Tecnologías de la comunicación

Las tecnologías de comunicaciones se basan en la transmisión de datos entre puntos distantes. Estos datos, se transmiten en forma de señales eléctricas y pueden ser enviadas através de cables o de manera inalámbrica. ONDAS: Una onda es una señal que se propaga por un medio. Por ejemplo el sonido, que es una onda mecánica que viaja usando el aire o cualquier otro material. Pero en el caso de las señales eléctricas pueden ser enviadas por el cable o a través del vacío (no necesitan un medio para transmitirse). Dependen de 3 parámetros principalmente: Amplitud: altura máxima de la onda. Hablando de sonido representaría el volumen. Si nos referimos a una onda eléctrica estaríamos representando normalmente el voltaje. Longitud de onda: distancia entre el primer y último punto de un ciclo de la onda (que normalmente se repite en el tiempo). Frecuencia: Número de veces que la onda repite su ciclo en 1 segundo (se mide en hertzios). (el periodo es otro parámetro, pero simplemente es la inversa de la frecuencia)

Dentro del espectro electromágnético encontramos diferentes tipos de señales dependiendo de las características de su onda.

TRANSMISIÓN INALÁMBRICA: BLUETOOTH.

• Es un protocolo de comunicaciones. Se creó por varias empresas comerciales (Ericsson, IBM, Intel, Toshiba y Nokia) sobre 1998. El objetivo era sustituir los cables para transmitir datos de un teléfono móvil al ordenador.

• Hoy en día, este grupo está formado por miles de empresas y se utiliza no sólo para teléfonos sino para cientos de dispositivos.

• Su curioso nombre viene de un antiguo rey Noruego y Danés, y su símbolo, de las antiguas ruinas que representan ese mismo nombre.

• Bluetooth es una red inalámbrica de corto alcance pensada para conectar pares de dispositivos y crear una pequeña red punto a punto, (sólo 2 dispositivos).

• Utiliza una parte del espectro electromagnético llamado “Banda ISM”, reservado para fines no comerciales de la industria, área científica y medicina. Dentro de esta banda también se encuentran todas las redes WIFI que usamos a diario. En concreto funcionan a 2,4GHz.

Hay 3 clases de bluetooth que nos indican la máxima potencia a la que emiten y por tanto la distancia máxima que podrán alcanzar:

También es muy importante la velocidad a la que pueden enviarse los datos con este protocolo:

Recuerda que:

• Mbps : Mega Bits por segundo.

• MBps: Mega Bytes por segundo.

Actividad ¿Cuantos ciclos por segundo tendrán las ondas que están en la Banda ISM? ¿Cuál es el periodo de esas ondas?

Actividad ¿A qué distancia y cuanto tiempo tardarían en enviarse los siguientes archivos por Bluetooth?

1. Un vídeo de 7Mb usando versión 2 clase 2 2. Una imagen de 2.5Mb usando versión 3 clase 1 3. Un archivo de texto de 240KB usando versión 1 clase 1

Bluetooth y Arduino Existen módulos adicionales que se pueden conectar a la placa básica Arduino que pueden dotar de una gran funcionalidad a los proyectos que queramos realizar. Nos permite establecer una comunicación inalámbrica con el entorno facilitando el diseño y el envío de datos al exterio

Descripción y esquemas Vamos a utilizar en estos ejemplos un módulo esclavo de bluetooth JY-MCU muy común y económico. Es posible

usar otros módulos ya que existe un mercado de desarrollo continuo, en cualquier caso el funcionamiento básico es

el mismo. Dicho módulo por tratarse de un módulo esclavo, está configurado para conectarse a un maestro y recibir órdenes de él. Como ya sabrás los dipositivos de este tipo tienen que “emparejarse” y tienen que compartir una contraseña para que los datos puedan intercambiarse. Por defecto, estos módulos tienen la contraseña 1234, aunque tanto esto como el nombre, pueden ser actualizados mediante unos comandos especiales, llamados AT y que veremos un poco más adelante. Arduino tiene 2 pines que permiten enviar y transmitir datos serie (uno datos tras otro). Lo usamos continuamente cuando enviamos un programa desde nuestro ordenador a Arduino o cuando hacemos una lectura desde el monitor serie (con un Serial.print();).

Arduino tiene definidos estos pines como:

• pin digital 0: RX <- (Arduino recibe a través de este pin).

• pin digital 1: TX -> (Arduino envía a través de este pin). El módulo bluetooth tiene 4 patillas. 2 para la alimentación y 2 para la comunicación.

Es MUY IMPORTANTE conectar de manera correcta estos pines con Arduino para la correcta comunicación. La patilla que emite los datos (TX) en el bluetooth debe estar conectada a la que recibe los datos (RX) en arduino, y viceversa. Aunque el módulo funciona a 3.3v, normalmente las placas comerciales, (como la que estamos usando), llevan un regulador y las podemos conectar directamente a los 5v de Arduino.

Una vez "pareados" los dos dispositivos bluetooth, desde Arduino podemos guardar los datos obtenidos con una simple instrucción: dato = Serial.read();

NOTA:

Ten en cuenta que estamos usando los 2 mismos pines que arduino usa para la comunicación USB con el ordenador (0, 1), así que siempre que quieras usar el cable para pasar el código o para leer datos desde el monitor, el bluetooth deberá estar DESCONECTADO. CONFIGURACIÓN DEL MÓDULO (AVANZADO): Inicialmente no necesitas configurarlo, sino que al cargar el código desde el ordenador, conectarás el módulo y este empezará a parpadear indicando que está buscando un master al que conectarse, (por ejemplo tu teléfono o una llave bluetooth usb conectado a un pc). Pero si quieres modificar cosas como la velocidad de conexión, el nombre o la contraseña de tu módulo, aquí te dejamos un código para que subas a tu arduino y mediante el monitor serie lo configures. Para ello hemos creado un nuevo puerto serie para que no interfiera con el USB y podamos usarlo simultáneamente, lo haremos en las patillas 10 y 11. Deberás conectar el módulo como ves en la figura, y luego cargar el código. Una vez súbido, abre la consola serie y (EN MAYÚSCULAS) ejecuta los comandos que necesites. Una vez finalizado, puedes desconectar el módulo BT y usarlo con normalidad.

Programa

#include <SoftwareSerial.h>

SoftwareSerial Serial1(11, 10);

//10:TX DEL MODULO, 11:RX DEL MODULO

String command = ""; // guardará la respuesta desde el BT

void setup()

{

Serial.begin(9600); //CONEXION SERIE USB CON ORDENADOR

Serial1.begin(9600); //CONEXION SERIE PARA EL MODULO BT

Serial.println("Terminal para configurar BT(JY-MCU)");

Serial.println("Comandos AT. USA MAYUSCULAS");

Serial.println("-----------------------------------");

Serial.println("Comando, Respuesta, Paramentros");

Serial.println("AT, OK,--Verifica la conexión--");

Serial.println("AT+VERSION,--Devuelve la version--");

Serial.println("AT+BAUDx, OKxxxx, Set x to: 1=1200 \

2=2400 3=4800 4=9600 5=19200 6=38400 7=57600 8=115200 \

--para cambiar la velocidad--");

Serial.println("AT+NAMEstring, nombrenuevo (20max)");

Serial.println("AT+PINxxxx, Cambia el pin (1234 por defecto)");

Serial.println("AT+ROLEx,1=MASTER/0=SLAVE --SOLO MASTER");

Serial.println();

}

void loop()

{

//Chequear si hay datos desde BT

if (Serial1.available()) {

while(Serial1.available()) {

command += (char)Serial1.read();

}

Serial.println(command);

command = "";

}

//Chequear si hay datos desde USB

if (Serial.available()){

delay(10); // necesita un pequeño delay

Serial1.write(Serial.read());

}}

Bluetooth maestro Vamos a hacer una especial mención a este tipo de módulos. Hemos comentado que las redes bluetooth se crean entre 2 dispositivos. Normalmente uno emite y el otro recibe, pero puede darse que los dos emitan y reciban. Para esto el módulo tiene que ser capaz de poder cambiar de modo master a slave. No todos los BT permiten hacer esto. Si compramos algún módulo económico para arduino, seguramente estaremos comprando un módulo SLAVE. Este sólo podrá recibir datos de otro dispositivo. Si queremos que nuestra arduino envíe datos deberemos usar un módulo MASTER. El módulo master es físicamente igual que el esclavo , aunque incorpora un firmware distinto HC-05 (firmware: las intrucciones que hacen que funcione al hardware). Otra diferencia es que lleva soldado al menos un pin más. Este pin llamado key, es necesario para que el módulo entre en modo de “comandos AT”, y así podamos programar su funcionamiento. Esto lo podemos hacer con el mísmo código que te hemos mostrado en el punto anterior. Para acceder a este modo especial en el master lo podemos hacer de 2 formas:

1. Conectando Key a 3.3v y encender el módulo. Así funciona a 38400 bauds. 2. Encendiendo el módulo y después conectando el key a 3.3v. Así funciona a 9600 bauds, (es más sencillo

pues es el que usa por defecto). Los comandos AT en HC-05, al contrario que en el HC-06 (esclavo), que es el que tendrá mucha gente , tienen que llevar el símbolo "=", por ejemplo: En HC-06: AT+NAMEnombre En HC-05: AT+NAME=nombre El datasheet indica que por defecto vienen con el modo CMODE=1 (para conectarse a cualquier esclavo disponible), sin embargo hay que comporbarlo (AT+CMODE?) por si tienen el CMODE=0 por lo que se intenta conectar al último emparejado, (en este caso no se emparejaría con ningún esclavo), así que hay que cambiar el CMODE con AT+CMODE=1) Puedes utilizar el código de la sección anterior para configurar el módulo master.

Arduino y dispositivos móviles Interactuar con el medio es uno de los objetivos primordiales de Arduino. En esta unidad vamos a ver cómo nos podemos comunicar con un dispositivo móvil, posibilitando así el control remoto de la placa.

Conocimiento previo

• Conectar dos dispositivos móviles por bluetooth.

• Programación básica de Arduino.

• Sentencias condicionales if-else, switch-case.

Objetivos • Aprender a comunicar vía Bluetooth cualquier dispositivo móvil con Arduino.

• Procesar la información recogida desde Arduino y realizar diversas acciones con esos datos. Lista de materiales:

• Arduino UNO.

• Dispositivo móvil

• App para envío de información (Blue Control en este caso).

• Ledes

• Placa de pruebas.

Descripción y esquemas La comunicación con Arduino es muy sencilla, el uso común de este dispositivo, será como receptor o emisor de datos.

En nuestro caso usaremos caracteres (bytes) que enviaremos desde un master, como un teléfono móvil. Hay muchas aplicaciones gratuitas para enviar datos, por ejemplo, para dispositivos Android podemos utilizar de manera gratuita:

• BlueControl

• BlueTerm Podemos hacer que un robot o vehículo se mueva dependiendo de las órdenes (letras) que reciba desde la aplicación del teléfono. Por ejemplo, la aplicación bluecontrol muestra unos iconos a modo de joystick, en este caso al pulsar sobre cada tecla, se envía una letra:

• Arriba: U

• Abajo: D

• Izquierda: L

• Derecha: R

• Centro: C El código de Arduino se basa en escuchar de forma continua el puerto serie. Cuando llegue un dato se ejecutará la acción que le indiquemos. Vamos a ver un ejemplo implementando un mosaico de LEDs:

Las conexiones serán las siguientes:

El objetivo es que según la tecla que presionemos en la aplicación “Blue Control”, se encenderá el led correspondiente: (arriba, abajo, izquierda, derecha y centro). Además si pulsamos alguno de los botones laterales, los leds deberán realizar una animación de todos los leds:

• Encendido de los leds en sentido horario.

• Encendido de los leds en sentido antihorario.

• Encendido intermitente de los leds exteriores y el interior.

• Encendido intermitente de todos los leds. INVENTA MÁS ANIMACIONES PARA INCLUIRLAS EN LOS BOTONES QUE SOBRAN EN LA APLICACIÓN Para simplificar el código, hemos creado funciones para ejecutar cada una de las animaciones, estas funciones están al final del programa. La lectura se hace mediante 2 funciones:

• La función Serial.available() nos indica si hay un dato disponible en el puerto serie (verdadero/falso)

• Con la función dato = Serial.read(); guardamos el dato en una variable (de typo byte) Con esto tendremos el código ASCII del caracter enviado por el maestro, por ejemplo si hemos enviado una A tendremos el 65, B = 66, a = 97, b = 98, ... (ascii.cl/es/) Lo único que nos queda es comparar el dato recibido y elegir la acción que tiene que hacer Arduino.

Programa

//LEDS CONECTADOS EN FORMA DE ESTRELLA Y UNO EN EL CENTRO

//mEDIANTE BLUETERM ENVIAMOS CARACTERES (SEGUN LAS TECLAS) Y SE

//ENCIENDEN / APAGAN LOS LEDS SELECCIONADOS

int ledArriba = 2;

int ledCentro = 6;

int ledAbajo = 4;

int ledDerecha = 3;

int ledIzquierda = 5;

byte dato;

////////////////////////////////////////////////////////////////////////

void setup() {

Serial.begin(9600);

pinMode(ledArriba,OUTPUT);

pinMode(ledAbajo,OUTPUT);

pinMode(ledIzquierda,OUTPUT);

pinMode(ledDerecha,OUTPUT);

pinMode(ledCentro,OUTPUT);

}

void loop() {

if (Serial.available()) //Guardamos en la variable dato el valor leido

dato= Serial.read();

//Comprobamos el dato

switch(dato)

{//Si recibimos una ...

case 85: //ARRIBA

{

digitalWrite(ledArriba, HIGH);

digitalWrite(ledAbajo, LOW);

digitalWrite(ledDerecha, LOW);

digitalWrite(ledIzquierda, LOW);

digitalWrite(ledCentro, LOW);

break;

}

case 68: //"U": ABAJO

{

digitalWrite(ledArriba, LOW);

digitalWrite(ledAbajo, HIGH);




break;

}

case 67: //"D": CENTRO

{





digitalWrite(ledCentro, HIGH);

break;

}

case 76: //"L": IZQ

{




digitalWrite(ledIzquierda, HIGH);


break;

}

case 82: //"R": DCH

{



digitalWrite(ledDerecha, HIGH);



break;

}

case 97: //Recibimos "a"

{

sentidoReloj();

break;

}

case 98: //Recibimos "b"

{

sentidoContrario();

break;

}

case 99: //Recibimos "c"

{

fueraDentro();

break;

}

}

}

void sentidoReloj(){


delay(100);


delay(10);


delay(100);


delay(10);


delay(100);


delay(10);


delay(100);


delay(10);

}

void sentidoContrario(){


delay(100);


delay(10);


delay(100);


delay(10);


delay(100);


delay(10);


delay(100);


delay(10);

}

void fueraDentro(){





delay(1000);





delay(10);

digitalWrite(ledCentro, HIGH);

delay(1000);


delay(10);

}

PRÁCTICAS PASO A PASO

LED parpadeante

Realizar un montaje con Arduino que produzca el parpadeo de un LED a intervalos de 0,5 segundos.

Te puedes basar en el ejemplo "Blink" que incluye el IDE de Arduino. El LED deberá estar conectado en el pin 8

ESQUEMA:

PROGRAMA:

#define pinLED 8

void setup() {

pinMode(pinLED, OUTPUT);

}

void loop() {

digitalWrite(pinLED, HIGH); // enciende el LED.

delay(500); // retardo en milisegundos

digitalWrite(pinLED, LOW); // apaga el LED.

delay(500);

}

Detector de luz

Realiza un montaje con Arduino para detectar cambios en el nivel de luminosidad del aula donde te encuentras. Para ello utiliza un sensor de luz LDR (light-dependent resistor), una resistencia eléctrica y un LED. La idea es que cuando la intensidad luminosa disminuya un cierto umbral, el LED se active. El sensor LDR es un sensor resistivo (fotoresistor), es decir que su resistencia eléctrica varía en función de la luz que recibe. Es un sensor analógico por lo que, para leer sus medidas, tenemos que conectarlo a una entrada analógica de Arduino. Si tapamos o acercamos el sensor a la luz veremos cómo cambian las medidas a través del monitor serie. El valor de la resistencia (R1) marcará la sensibilidad de las medidas y dependerá también del rango de resistencias que nos proporcione el LDR. Puedes empezar un una resistencia de 1KOhmio.

ESQUEMA:

Para el sensor LDR:

Circuito completo:

PROGRAMA:

// Detector de luz con LDR

#define pinLED 12

void setup() {


Serial.begin(9600);

}

void loop() {

int v = analogRead(A0);

// El valor 600 (siguiente línea) se debe de ajustar dependiendo de la luz en el

local

// y del valor de la resistencia pull-down

// poca luz -> v pequeño, mucha luz -> v grande.

if (v < 600) digitalWrite(pinLED, HIGH);

else digitalWrite(pinLED, LOW);

Serial.println(v);

}

Actividad Modifica el montaje anterior sustituyendo la resistencia fija por una variable (potenciómetro). Comprueba que se puede ajustar manualmente el valor de luminosidad que se obtiene desde el sensor LDR.

Secuencia de LED Realizar un montaje con 3 LEDs (rojo, verde y amarillo) que realice la siguiente secuencia con un intervalo de tiempo de 0,5 segundos entre cada uno ('1' indica encendido y '0' apagado):

1. 100 (LED rojo encendido y el resto apagado). 2. 010 (LED verde encendido y resto apagado). 3. 001 (LED amarillo encendido y resto apagado).

ESQUEMA:

PROGRAMA:

#define pinLED1 8

#define pinLED2 9

#define pinLED3 10

void setup() {

pinMode(pinLED1, OUTPUT);



}

void loop() {

digitalWrite(pinLED1, HIGH); // enciende

digitalWrite(pinLED2, LOW); // apaga

digitalWrite(pinLED3, LOW); // apaga

delay(500);

digitalWrite(pinLED1, LOW);

digitalWrite(pinLED2, HIGH);


delay(500);



digitalWrite(pinLED3, HIGH);

delay(500);

}

Actividad Añade un cuarto LED a la práctica anterior y realiza la siguiente secuencia (se indican los LEDs y el retardo) : 1000 - 0.5s - 0100 - 0.3s - 0010 - 0.5s - 0001 - 0.3s - 1111 - 0.2s - 0000 - 0.2s

Detector de luz

Realiza un montaje con Arduino para detectar cambios en el nivel de luminosidad del aula donde te encuentras. Para ello utiliza un sensor de luz LDR (light-dependent resistor), una resistencia eléctrica y un LED. La idea es que cuando la intensidad luminosa disminuya un cierto umbral, el LED se active. El sensor LDR es un sensor resistivo (fotoresistor), es decir que su resistencia eléctrica varía en función de la luz que recibe. Es un sensor analógico por lo que, para leer sus medidas, tenemos que conectarlo a una entrada analógica de Arduino. Si tapamos o acercamos el sensor a la luz veremos cómo cambian las medidas a través del monitor serie. El valor de la resistencia (R1) marcará la sensibilidad de las medidas y dependerá también del rango de resistencias que nos proporcione el LDR. Puedes empezar un una resistencia de 1KOhmio.

ESQUEMA:

Para el sensor LDR:

Circuito completo:

PROGRAMA:

// Detector de luz con LDR

#define pinLED 12

void setup() {


Serial.begin(9600);

}

void loop() {

int v = analogRead(A0);

// El valor 600 (siguiente línea) se debe de ajustar dependiendo de la luz en el

local

// y del valor de la resistencia pull-down

// poca luz -> v pequeño, mucha luz -> v grande.

if (v < 600) digitalWrite(pinLED, HIGH);

else digitalWrite(pinLED, LOW);

Serial.println(v);

}

Actividad Modifica el montaje anterior sustituyendo la resistencia fija por una variable (potenciómetro). Comprueba que se puede ajustar manualmente el valor de luminosidad que se obtiene desde el sensor LDR.

Detector de objetos por infrarrojos (IR).

Realizar un montaje que utilice el sensor digital de infrarrojos modelo Keyes IR. Cuando detecte un objeto que encienda el LED 13 de Arduino. También es necesario que muestre el valor binario leído del sensor por el monitor serie.

Como se puede observar en la figura el emisor y el receptor van montados en la misma placa. El emisor transmite una frecuencia de infrarrojo y cuando encuentra un objeto la señal se refleja y es captada por el receptor. La distancia de detección es de 2 a 40 cm (bastante menor que el rango del sensor de ultrasonidos). Tiene un jumper que deshabilita el sensor si se quita y dos potenciómetros. Con uno de ellos (el 202) regulamos la distancia a la que se detecta el objeto. La radiación infrarroja no se ve directamente, pero si enfocamos mediante la cámara del móvil como si fuéramos a hacer una foto veremos por el visor del móvil una luz violeta.

ESQUEMA:

Pin Sensor IR Pin Arduino

Vcc 5V

GND GND

Out D3

EN Sin conectar

PROGRAMA:

#define LED 13

#define BUTTONPIN 3

boolean val;

void setup (){

pinMode (LED, OUTPUT);

pinMode (BUTTONPIN, INPUT);

Serial.begin(9600);

}

void loop (){

val = digitalRead(BUTTONPIN);// digital interface will be assigned a value of 3 to

read val

if (val == HIGH) digitalWrite (LED, HIGH);

else digitalWrite(LED, LOW);

Serial.println(val);

}

Actividad Comprueba que la señal de infrarrojos NO rebota sobre una superficie negra. Prueba con cinta aislante negra. Este sería el principio de funcionamiento de un robot siguelíneas. ¿Cómo se podría diseñar con sensores IR para seguir una línea negra? Razona la lógica de funcionamiento.

Detector de objetos por ultrasonidos (US).

Esta práctica consiste en montar un sistema con Arduino capaz de medir la distancia (cm) a la que se encuentra un objeto y mostrarla por el monitor serie. Para ello usaremos el sensor de ultrasonidos HC-SR04. Este sensor dispone de un emisor y receptor de ondas de ultrasonidos. El emisor "dispara" una onda ultrasónica que se propaga a 340 m/s y se inicia un temporizador. Si encuentra un objeto, la onda rebota. Esta onda reflejada o eco es capturada por el módulo receptor y el temporizador interno se para. De esta manera midiendo el tiempo que la onda tarda en ir y reflejarse, junto con la velocidad de propagación, el sensor calcula la distancia a la que se encuetra el objeto. El sensor dispone de 4 pines: Alimentación (+5V), Tierra (GND), Trigger y Echo. El pin Trigger se encarga de "disparar" la señal de ultrasonidos por el transmisor. Se hace enviado un nivel alto desde Arduino al pin digital donde esté conectado el pin Trigger. El pin Echo se encarga de enviar a Arduino un pulso (nivel alto) con duración proporcional a la distancia a la que se encuentra el objeto detectado, más exactamente distancia (cm) = microsegundos del pulso / 29. Mediante la instrucción PulseIn de Arduino podemos leer la duración de ese pulso. El sensor tiene un rango de 2 cm a 400 cm. Para más información consultar la hoja de especificaciones del sensor: http://www.micropik.com/PDF/HCSR04.pdf

ESQUEMA:

Pin Sensor US Pin Arduino

Vcc 5V

Trigger D8

Echo D9

GND GND

http://www.micropik.com/PDF/HCSR04.pdf

PROGRAMA 1:

int trigPin = 8;

int echoPin = 9;

long duration; //tiempo de ida/vuelta

int cm = 0; //Para almacenar el valor obtenido en cm valor=0

void setup() {

Serial.begin(9600);

pinMode(trigPin, OUTPUT);

pinMode(echoPin, INPUT);

}

void loop()

{

//ponemos al trigger a low para activarlo después

digitalWrite(trigPin, LOW);

delayMicroseconds(2);

//Activar el módulo con un pulso de 10microsec.

digitalWrite(trigPin, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin, LOW);

//Esperamos la llegada de un pulso HIGH

duration = pulseIn(echoPin, HIGH); // valor del pulso alto en microsegundos

//tiempo de ida y vuelta, dividimos por 2

duration=duration/2;

//La velocidad del sonido es de 340 m/s

//El pin echo entrega un pulso alto

//de una duración de 29 microsegundos

//por cada centímetro de distancia

//a la que esté el objeto.

cm = duration/ 29;

Serial.print("Distancia:");

Serial.println(cm);

delay(100); // Nos aseguramos de que el siguiente trigger

// y el echo actual no se mezclen (recomiendan 50 ms).

}

OTRO MÉTODO USANDO UNA LIBRERÍA EXTERNA: En este caso tenemos que descargar previamente el archivo comprimido (.zip) de la librería NewPing e instalarla desde la opción del IDE de Arduino Programa -> Incluir librería -> Add Library y seleccionar NewPing.zip (normalmente estará descargado en la carpeta de Descargas).

#include <NewPing.h>

#define TRIGGER_PIN 8

#define ECHO_PIN 9

#define MAX_DISTANCE 200

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {

Serial.begin(9600);

}

void loop() {

delay(50);

int uS = sonar.ping();

Serial.print("Ping: ");

Serial.print(uS / US_ROUNDTRIP_CM);

Serial.println("cm");

}

Actividad Diseña un circuito y realiza un programa que haga sonar un zumbador cuando un objeto se encuentre a menos de 5 cm del sensor.

Comunicación por Bluetooth.

Realizar un montaje que conecte Arduino y una dispositivo móvil a través de Bluetooth. Para ello utilizaremos un módulo HC-06 para Arduino y la aplicación para Android Bluecontrol. Ambos dispositivos se tienen que emparejar y compartir una contraseña para que los datos puedan intercambiarse. Por defecto, estos módulos tienen la contraseña 1234. Normalmente el módulo de bluetooth tiene un LED que parpadea cuando se está intentando conectar con el móvil. Una vez hecho, la luz del LED permanece fija. Vamos a realizar un montaje que encienda o apague un par de LEDs desde el dispositivo móvil. La aplicación Bluecontrolenvía caracteres ASCII al dispositivo con el que está pareado el móvil (módulo HC-06 de Arduino), y éste los procesa para encender o apagar los LEDs. IMPORTANTE:

• En el momento de cargar el programa desde el IDE a la placa Arduino hay que desconectar el módulo de Bluetooth para que no interfiera.

• El pin de transmisión del Bluetooth Tx se conecta al de recepción de Arduino Rx.

• El pin de recepción del Bluetooth Rx se conecta al de transmisión de Arduino Rx.

MONTAJE:

PROGRAMA:

// Desde la aplicación del movil (bluetooth) se encienden y

//apagan dos LEDs con las flechas UP/DOWN

//Cuando pulsa la flecha UP envía una 'U' cuyo código

//ASCII es 85

//Cuando pulsa la flecha DOWN envía una 'D' cuyo código

//ASCII es 68

#define LED1 8

#define LED2 10

byte dato;

void setup(){

Serial.begin(9600);

pinMode(LED1, OUTPUT);

pinMode(LED2, OUTPUT);

}

void loop(){

if (Serial.available()) dato = Serial.read();

Serial.println(dato);

if (dato == 85) { // UP

digitalWrite(LED1, HIGH);

digitalWrite(LED2, LOW);}

if (dato == 68) { // DOWN

digitalWrite(LED2, HIGH);

digitalWrite(LED1, LOW);}

}

Actividad Diseña un sistema que sustituya los LEDs por dos servomotores de giro continuo de tal manera que se pueda controlar el giro desde la aplicación del móvil.Este es el punto de partida de un robot móvil controlado a distancia.

Medida de la temperatura y la humedad ambiente.

Realizar un montaje que mida temperatura y humedad mediante el sensor DHT11. Para ello tendrás que realizar las conexiones necesarias para poder obtener los datos desde Arduino. Se trata de un sensor digital que utiliza 3 pines: Alimentación +5V, tierra/GND (-) y pin de datos (out) por donde se envían los datos de humedad y temperatura. A veces el sensor viene sobre 4 pines, en este caso uno de ellos no se conecta. Como las medidas de humedad y temperatura van por un solo pin, la información se transmite como un tren de pulsos en serie, por lo tanto, necesitamos un programa que "extraiga" eso dos datos de forma diferenciada. Para ello vamos a usar una librería referenciada por DHT11.h que se puede descargar desde: https://drive.google.com/file/d/0B2B9eCp8wRQhdTQwY196cHFfckk/view?usp=sharing * Nota: Si ocurriera que enlace estuviera roto en el momento de la descarga, hay muchas alternativas para la descarga de la librería. Busca en Google DHT library y podrás obtenerla de otros sitios. Después hay que instalar la librería en el directorio (carpeta) correspondiente. Ver anexo de "Instalación de librerías en Arduino". A través del monitor serie del IDE de Arduino podremos ver las medidas obtenidas.

ESQUEMA: Si el sensor viene montado en una placa con 3 pines serigrafiados (como en la imagen de arriba), las conexiones son las siguientes:

PIN DHT11 PIN ARDUINO

+ +5V

- GND

OUT / DATOS 2 (digital)

En el caso de que el sensor venga sin montar en placa (4 pines) las conexiones son las siguientes: NC -> No se conecta y D2 -> pin digital 2

Las especificaciones técnicas del sensor se pueden encontrar en: http://www.micro4you.com/files/sensor/DHT11.pdf

PROGRAMA:

#include "DHT.h"

#define DHTPIN 2



void setup() {

Serial.begin(9600);

dht.begin();

}

void loop() {

delay(2000);


https://drive.google.com/file/d/0B2B9eCp8wRQhdTQwY196cHFfckk/view?usp=sharing

http://www.micro4you.com/files/sensor/DHT11.pdf




return;

}

Serial.print("Humedad: ");

Serial.println(h);

Serial.print(" %\t");

Serial.print("Temperatura: ");

Serial.println(t);

Serial.print(" *C ");

Serial.println("");

}

Representación gráfica de medidas con Processing.

Representar gráficamente en la pantalla del ordenador mediante un programa en Processing los datos obtenidos de temperatura y humedad. Una vez obtenidos los datos de temperatura y humedad a través del sensor DHT11 desde Arduino, enviamos, a través del puerto serie, estos datos al PC, donde tenemos ejecutando un programa en Processing que está "escuchando" el puerto serie, obteniendo los datos y representándolos en pantalla. Simultáneamente guardamos los datos en un archivo de texto que posteriormente podremos analizar en una hoja de cálculo. IMPORTANTE: No hay que tener abierto el monitor serie del IDE de Arduino porque ocupa el puerto y, por lo tanto, no deja leer los datos a Processing.


#include "DHT.h"

#define DHTPIN 2



void setup() {

Serial.begin(9600);

dht.begin();

}

void loop() {

delay(2000);





return;

}

// Únicamente enviar a Processing las variables t y h

Serial.println(h);

Serial.println(t);

}

PROGRAMA A EJECUTAR EN PROCESSING (PC / LAPTOP): Vamos a guardar dos archivos en Processing, al primero le llamamos visual_dot.pde y al segundo Graf.pde. Ambos lo guardamos en el mismo directorio.

/*

Tildes omitidas en los comentarios.

visual_dot.pde

*/


int x = 65, ancho = 700, alto = 600;

boolean p = true;

int cFondo = 240; //Color fondo

PrintWriter datos;

Serial puertoArduino;

Graf g = new Graf(ancho, alto, cFondo);

void setup (){

size(ancho, alto);

background(cFondo);

print(Serial.list());

//ojo el '0' de Serial.list()[0]

//se cambia por el orden de numero de puerto de tu ordenador

puertoArduino = new Serial(this, Serial.list()[0], 9600);

// Guardaremos los datos muestreados en un archivo de texto,

// asi podremos analizarlos con una hoja de calculo y otro programa.

datos = createWriter("medidas.txt");

fill(0, 0, 255);

text("VOLTIOS (Digital): ", 20, 40);

text("Muestras", ancho / 2, alto - 20);

g.cuadricula();

}

void draw(){

String inString = puertoArduino.readStringUntil('\n');

if (inString != null){

inString = trim(inString);

float val = float(inString);

datos.print(val + "\n"); // copia el dato en medidas.txt

g.puntos(x, val, p);

p = false;

x = x + 20;

if (x > ancho - 60) {x = 60;

g.borra();

g.cuadricula();

p = true;

}

}

}

void keyPressed() {//Presionar 'ESC' para salir

datos.flush();

datos.close();

exit();

}

/*

Tildes omitidas en los comentarios.

Graf.pde

*/

class Graf {

int nX, nY, colF;

float coordAntX, coordAntY;

Graf (int x, int y, int cF){

nX = x;

nY = y;

colF = cF;

}

void cuadricula(){

stroke(0);

for (int j = 60 ; j <= nX - 60; j = j + 20){

line (j, 60, j, nY - 60); } // Vert

for (int j = 60 ; j <= nY - 60; j = j + 20){

line (60, j, nX - 60, j);} // Horiz

}

void borra(){

fill(colF); // Color del fondo

noStroke();

rectMode(CORNERS);

rect(50 , 50, nX , nY - 30 );

}

void puntos(int x, float nValor, boolean primera){

fill(255,255,255);

rectMode(CORNERS);

rect(140,25,200,45);//Borra lectura anterior

fill (0,0,255);

text(nValor, 142, 40);

fill(0, 0, 255);

float v = map(nValor, 0, 1023, nY - 60, 60); //Mapeo inverso entre

//los margenes sup e inf.

ellipse(x, v, 5, 5);

//Une los dos puntos con una linea excepto en la primera lectura.

if (primera == false){

line (coordAntX, coordAntY, x, v);

}

coordAntX = x;

coordAntY = v;

}

}

Créditos Este material ha sido elaborado por:

• Manuel Hidalgo Díaz.

• Jorge Muñoz Rodenas.

• Pablo Evaristo García Palacios.

• Jorge Luis Loza Luis. Los vídeos que aparecen en este manual son de elaboración propia de los autores así como las fotografías de los montajes y esquemas eléctricos. Otras imágenes, principalmente las que ilustran las portadas de los capítulos se han descargado desde repositorios de imágenes libres.

El manual se distribuye bajo licencia Creative Commons tipo by-sa Este recurso ha sido subvencionado por el Ministerio de Educación, Cultura y Deporte a través de la convocatoria de ayudas para la elaboración de recursos didácticos para su incorporación a las plataformas de acceso público 2014. Todas las actuaciones descritas en este recurso comprometen exclusivamente a los autores del mismo. Debido al carácter "vivo" de esta publicación, los autores mantienen una réplica en el portal www.practicasconarduino.com donde se publican periódicamente modificaciones al manual, añadiendo nuevos contenidos y revisiones de la placa Edubásica.

http://www.practicasconarduino.com/

Documents

Información básica sobre Arduino - WordPress.comWidth Modulation) o proporcionan una onda cuadrada con un nivel alto (+5V) de “cierta” duración. Es muy útil para activar servomotores