Con la tecnología de Blogger.

aclarando cosas

Estaría feo llamarle a esto manual de Arduino. Los manuales los escriben expertos, y nosotros estamos lejos de ser expertos de nada, y menos de Arduino.



Lo que tienes ahora mismo delante no es más que una recopilación, adaptación, traducción etc, etc…, con la que sólo se pretende que no pases las horas que hemos pasado nosotros buceando en internet. Muchos de los textos los hemos sacado de la página oficial de Arduino, otros de páginas de fabricantes o distribuidores de componentes, y en la mayoría de las veces nos hemos limitado a adaptarlos al contexto de un aula de tecnologías de ESO o Bachillerato, si eso todavía existe cuando leas esto.

¿arduino?¿ qué es eso?

Arduino es una plataforma de electrónica abierta para la creación de prototipos basada en software y hardware flexibles y fáciles de usar. Siempre cuentan que se creó para artistas, diseñadores, aficionados y cualquiera interesado en crear entornos u objetos interactivos que no en muchas ocasiones no tenemos altos conocimientos de electrónica o programación.


Arduino es una placa que recoge información del entorno por medio de sensores (pulsadores, sensores de temperatura, de presencia, de luminosidad, micrófonos…), conectados a sus pines (conectores) de entrada, controlando de este modo cualquier cosa que nosotros queramos conectar a los pines de salida,  ya sean luces, motores y otros actuadores.

pines

Cada vez que intento leer algo sobre arduino me encuentro con la palabra PIN.

No son más que conectores. Por ejemplo una placa Arduino Uno tiene 14 pines digitales y seis analógicos, aunque estos últimos se pueden configurar también como digitales.



Ahora es cuando toca recordar que una señal analógica es aquella cuyo valor varía entre un mínimo y un máximo. Por ejemplo, la medida de la temperatura, de la intensidad de luz, etc…

Una señal digital es más básica, y su valor sólo puede ser encendido (HIGH en Arduino) o apagado (LOW).

Dependiendo de lo que queramos medir y de las características de nuestro sensor, usaremos una entrada digital o analógica.

Además de éstos nuestra placa tiene otra serie de pines, como son:



  •  IOREF, un duplicado de +5v 
  •  Reset, con el que podemos controlar un reset de nuestra placa 
  •  3,3 v, salida positiva de voltaje. 
  •  5v, salida positiva de voltaje. 
  •  GND, pin de tierra, el negativo de nuestros montajes. 
  •  Vin, nos permite una entrada de alimentación externa 


 Cada uno de ellos se puede configurar como entrada o salida con una sencilla instrucción. Tan simple como poniendo pinMode (13, OUTPUT) estaremos configurando el pin 13 como SALIDA.

proyectos realizados en el aula

Durante el presente curso se han realizado en el aula diversos e interesantes proyectos de robótica utilizando arduino...



La "yogurtería" de Ángela, Fran y Tamara, cuyo escaparate se encendía automáticamente cuando era de noche y además se acercaba alguien a verlo. Un ventilador aireaba el local si la temperatura aumentaba más de lo previsto, y la apertura y cierre de las puertas se accionaba al detectar un sonido de una determinada intensidad.



Francisco, Luis Miguel y Marcos diseñaron una vivienda inteligente en la que la puerta de la cochera y la iluminación de la misma se accionaban al detectar al vehículo, y contaba con un ascensor cuya luz se encendía al detectar presencia y su puesta en marcha atendía a ordenes por voz. Similares funciones realizaba el edificio inteligente de Miguel, Eduard y Sergio.


Salomé, Clara y Antonio diseñaron un invernadero que controlando la luz, la temperatura  y  la humedad de la tierra accionaba los ventanales, ventiladores y sistema de riego automático.


La "baticao" de Emma, Paula y José Angel preparaba el desayuno automáticamente. Al sentir la presencia de la taza, la gira hasta el dispensador, donde se produce el llenado hasta que el peso de la misma es el programado. A la vez controla que la temperatura del desayuno sea la prevista. 



La casa para mascotas de Jorge, José Luís e Iván detectaba la presencia o no de la mascota. Dependiendo si es de noche o no, cierra las puertas y controla el sistema de calefacción, avisando al dueño si está dentro o fuera. Un sistema también robotizado se encarga de reponer tanto el agua como el pienso de la mascota.


Otros alumnos dedicaron sus esfuerzos a la robótica de competición, desarrollando robots siguelíneas.


De los primeros prototipos con los que participaron en el campus de Alcoi en la Semana de la Ciencia de la UPV y con los que consiguieron meritorias clasificaciones...


... hasta los rapidísimos robots con los que participaron en el Desafío Robot 2014 de la Ciudad de las Ciencias en Valencia



Prueba del entusiasmo con el que el alumnado acogió este tipo de actividades es que gran parte de ellas se realizaron por la tarde, fuera del horario escolar, y con asistencia voluntaria.

¿por qué arduino?



Las razones por las que utilizar Arduino pueden resumirse en:

1.   Es una plataforma de Hardware y software libre. Ello supone que no dependemos de que una marca comercial decida el rumbo sino que miles de desarrolladores diseñen el futuro de arduino

2.    Permite usarse bajo Windows, Mac OS x, o Linux

3. No precisa de grandes conocimientos de electrónica, ni de robótica, ni de programación.

4.    Es económico. Ninguna de las placas que utilizamos en clase han costado más de 25 €.

5.   Existe una inmensa y creciente comunidad en internet que nos ofrece infinidad de programas, ejemplos, proyectos, foros, ayuda….

  

instalando arduino. ¿qué necesito?

Para empezar a trabajar con Arduino sólo necesitamos una de las distintas placas Arduino que existen, un ordenador con Windows, Mac OS X, o Linux, un cable y un cable usb que los conecte. Ah, y dedicarle unas cuantas horas…



1.     Descarga la IDE de Arduino. Para ello visita la página de descargas. Ya empezamos… ¿qué es eso del IDE? El IDE es nuestro interface con el que nos comunicaremos con nuestra placa. Lo utilizaremos para crear nuestros programas, depurarlos, compilarlos para que los entienda nuestra placa, y enviarlos a la misma. Tiene un aspecto más o menos así.






2.     Conecta la placa Arduino a tu ordenador usando el cable USB. El LED verde indicador de la alimentación (nombrado como PWR en la placa) debería quedar encendido a partir de ese momento.

3.     Instala los drivers. Cuando conectas la placa, Windows debería inicializar la instalación de los drivers (siempre y cuando no hayas utilizado ese ordenador con una placa Arduino anteriormente).
En Windows Vista y Windows 7, los drivers deberían descargarse e instalarse automáticamente.
En Windows XP, se abrirá el diálogo de instalación de Nuevo Hardware:
·Cuando te pregunten: ¿Puede Windows conectarse a Windows Update para buscar el software? selecciona No, no esta vez. Haz click en Siguiente.
·Selecciona Instalar desde una lista o localización específica (Avanzado) haz click en Siguiente.
·Asegúrate que Buscar los mejores drivers en estas localizaciones esté seleccionado; deselecciona Buscar en medios removibles; selecciona Incluye esta localización en la búsqueda y navega al directorio drivers/FTDI USB Drivers dentro de la carpeta de Arduino que has descomprimido previamente. (La versión más reciente de los drivers se puede encontrar en la página web del fabricante del chip FTDI.) Haz click en Siguiente.
·El asistente de instalación buscará los drivers y te anunciará que encontró un "USB Serial Converter" (se traduce por Conversor USB-Serie). Haz click en Finalizar.
·El asistente de instalación de hardware volverá a iniciarse. Repite los mismos pasos que antes y selecciona la misma carpeta de instalación de los drivers. Esta vez el sistema encontrará un "USB Serial Port" (o Puerto USB-Serie).
   Puedes comprobar que los drivers se han instalado correctamente abriendo la carpeta del Administrador del Dispositivos, en el grupo Dispositivos del panel de control del sistema. Busca "USB Serial Port" (o Puerto USB-Serie) en la sección de puertos; esa es tu placa Arduino.

Abrimos nuestro IDE. Lo  primero que tenemos que hacer es una sencilla configuración que supone elegir nuestra placa y el puerto a la que la tenemos conectada. Para ello vamos al menú HERRAMIENTAS del que nos interesan dos pestañas, la pestaña TARJETA, en la que después de desplegarla elegiremos la nuestra, y la pestaña PUERTO SERIAL, en la que seleccionaremos el puerto al que tenemos nuestra placa. Si no sabemos cuál es, lo comprobaremos en la pantalla que vemos en la imagen de arriba.



las placas

Existen infinidad de tipos de placas. Cada día salen nuevas. Por comodidad, respeto a los creadores y por ser una de las más extendidas nosotros vamos a usar la ARDUINO UNO rev3.
Las placas pueden ser hechas a mano o compradas montadas de fábrica; el software puede ser descargado de forma gratuita. Los ficheros de diseño de referencia (CAD) están disponibles bajo una licencia abierta, así pues eres libre de adaptarlos a tus necesidades.

El equipo Arduino (Arduino team) es: Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, y David Mellis.

¿cómo me comunico con la placa?

Para programar el microcontrolador en la placa Arduino en el aula usaremos el lenguaje  lenguaje de programación Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Los proyectos hechos con Arduino pueden ejecutarse sin necesidad de conectar a un ordenador, si bien tienen la posibilidad de hacerlo y comunicar con diferentes tipos de software (p.ej. Flash, Processing, MaxMSP. En educación también se usa mucho el SCRATCH, concretamente una versión específica llamada S4A –scratch for Arduino- un entorno gráfico muy intuitivo.





¿qué podemos hacer con arduino?

Una de las características más interesantes de Arduino es que es lo suficientemente intuitivo como para poder empezar a trabajar en proyectos sencillos, pero a la vez nos permite incrementar la complejidad de los mismos de manera prácticamente infinita. Con Arduino podemos automatizar cualquier proyecto en el aula, hacer robots sencillos, manejar la información que genera cualquier sensor. Pon “proyectos de arduino” en Youtube y te darás cuenta de las infinitas posibilidades de Arduino.





nuestra primera práctica con arduino

Vamos a cargar nuestro primer programa con Arduino. Lo encontraremos dentro del IDE del arduino, en el menu  Archivo/ejemplos/basics/blink

El programa enciende intermitentemente un LED conectado directamente a la placa de Arduino. No necesitaremos protoboard en esta ocasión.



La estructura de todos los programas Arduino es igual.

// Enciende un LED un segundo y apágalo otro segundo repetidamente.

/* Aquí van comentarios iniciales del autor. Todo lo que vaya detrás de esa barra asterisco no participa en el programa, por tanto no es cargado en la placa. Debemos cerrarlo con un */

/* parpadeo

*/
void setup() {                        // poniendo una doble barra podemos incluir explicaciones. En este caso arrancamos el “setup” de nuestro programa, es decir, las condiciones previas que servirán para todo el programa y que sólo se cargarán una vez

pinMode (13, OUTPUT);      // definimos el pin 13 como SALIDA. Siempre hay que decirle a nuestra placa si un pin lo hemos definido como OUTPUT o INPUT. siempre debemos terminar la instrucción con un ;  !!!
}                                              // como abrimos llaves para definir el setup, debemos cerrarlas!!

// a partir de aquí creamos el bloque LOOP, el "alma" del programa. Este bloque se reproducirá una y otra vez mientras no digamos lo contrario

void loop() { 
digitalWrite(13, HIGH);         // manda una señal digital HIGH (encendido, +5v) al pin 13. El pin 13 es el único de nuestra placa arduino que lleva una resistencia integrada de forma que podemos insertar un LED directamente. No utilices otro pin, ya que mandarás 5v al LED y te lo cargarás.
delay(1000);                          // delay significa "espera". Con delay 1000 esperaremos 1000                                           milisegundos! cuidado!
digitalWrite(13, LOW);          // manda una señal LOW (apagado) digital al pin 13
delay(1000);                          // vuelve a esperar un segundo

// a partir de aquí, mientras no le digamos lo contrario nuestro programa se ejecutará infinitamente, porque el bucle no recibe ninguna orden de stop
}                                  // igual que antes, toda llave abierta hay que cerrarla. Fin del programa.



Pruébame


A partir de aquí es sencillo manipular el sketch a nuestro gusto.

1.      Cambia el intervalo de tiempo a 0,25 seg

2.      Cambia sólo el de apagado.

3.      Haz secuencias llamativas.


Vamos a montar lo mismo en una protoboard. Esto nos permitirá incluir más elementos en nuestra práctica. Recuerda que en una protoboard, los pines van conectados internamente así:




Para usar los leds  los montaremos con una resistencia en serie de entre 220Ω y 270Ω. Algo así



Las salidas digitales 7, 8 y 9 nos darán el +5v, mientras que cerraremos cada circuito con el pin GND de nuestra placa Arduino.

A partir de aquí ya debes ser capaz de controlar los led. Te echo una mano al principio, pero no te acostumbres. Intenta entender el sketch, ahora llevará menos explicaciones.

/* parpadeo de tres leds
*/

void setup()                            //definimos parámetros iniciales
{                             

pinMode (7, OUTPUT);        // definimos los pines 7, 8 y 9 como SALIDAS
pinMode (8, OUTPUT);
pinMode (9, OUTPUT); 
}

void loop() { 
digitalWrite(7, HIGH);           // mandamos a los pines 7, 8 y 9 la señal digital
digitalWrite(8, HIGH);           // HIGH,encendido
digitalWrite(9, HIGH);     
delay(1000);                           // esperamos 1000 milisegundos, siii, un segundo...

digitalWrite(7, LOW);            // mandamos a los pines 7, 8 y 9 la señal digital
digitalWrite(8, LOW);           // LOW, apagado
digitalWrite(9, LOW); 
delay(1000);                            // volvemos a esperar un segundo, y ejecutamos de nuevo el loop
                                                                
}                                              // importante, cerramos el bucle

¿has entendido qué hace cada instrucción? Perfecto! Si es así y has sido capaz de encender y apagar los tres leds, ahora toca jugar. Puedes hacer combinaciones infinitas con los leds encendidos o apagados y con los intervalos de tiempo.

1.      Prueba a simular un semáforo.

2.      Haz las luces del coche fantástico.

3.      Monta más leds y haz combinaciones llamativas. No te olvides de las resistencias!



entradas. El pulsador

Al encender un led estamos usando SALIDAS, es decir, nuestra placa está provocando algo en el exterior. Mediante ellas podemos encender y apagar un led, controlar el giro de un motor, escribir en una pantalla, activar un zumbador, y todo lo que se te ocurra.

Arduino nos permite además configurar los pines como ENTRADAS. De está manera lo que estaremos haciendo es obtener información del entorno.

La forma más elemental de interactuar con él es mediante un pulsador.

Sería un error comparar esto que acabamos de decir con un circuito eléctrico elemental mediante el cual encendemos un led al activar un pulsador. Sin caer en fantasmadas, nuestro proceso es mucho más complejo. A diferencia de ese circuito, en el que el pulsador es un simple “grifo” que deja pasar o no electrones capaces de encender a su paso un led, en nuestro proceso sucede:

Leemos el valor de una entrada. Esta puede ser:


DIGITAL: esperamos valores de encendido/apagado, en nuestro lenguaje HIGH/LOW. Sería el caso por ejemplo del pulsador.


ANALÓGICA. El valor medido varía entre un valor cero y un máximo, normalmente 255. Podría ser el valor que obtenemos al medir la luz con un LDR.


En función del valor que obtenemos, ordenamos una acción.

¿No ves la diferencia? :) . Hemos elegido la forma de entrada y salida más sencillas, pero a partir de aquí podemos complicarnos la vida todo lo que queramos. Vamos a montar la práctica. Usaremos el sketch que viene en ejemplos/digital llamado BUTTON. Lo cargamos y aparece en nuestro IDE así:

*/  Botón. Enciende y apaga un LED conectado al pin 13 cuando apretamos un pulsador conectado al pin 2 */
const int buttonPin = 2;                  // indica el pin del pulsador
const int ledPin =  13;                    // indica el pin del led
int buttonState = 0;                        //al poner solo int, el estado del botón, buttonState, será una                                                              variable con valor incicial 0.

void setup() {
   pinMode(ledPin, OUTPUT);            // pin del led como SALIDA
   pinMode(butttonPin, INPUT);          // pin del botón como ENTRADA
}
void loop()
buttonState = digitalRead(buttonPin);                // lee el valor  de la variable estado del botón
if (buttonState == HIGH) {                                    // SI la variable digital, es “HIGH”...:
digitalWrite(ledPin, HIGH);                                 // enciende el pin
}
else {                                                     // en otro caso...:
digitalWrite(ledPin, LOW);                 // apaga el LED
}
}
¿fácil? Seguro que si.

El esquema del montaje es el siguiente:




Ahora para sacarle partido a nuestros avances, podríamos cambiar tanto las entradas como las salidas. En lugar de poner un sencillo pulsador vamos a poner ahora un SENSOR DE LUZ. Para ello usaremos un LDR, Light Dependent Resistor, que para los que nos llevamos regular con el inglés no es más que una resistencia cuyo valor varía con la luz que incide sobre ella. Con poca luz, su resistencia es muy alta, y va bajando conforme lo iluminamos 

midiendo la cantidad de luz

Esta vez no queremos obtener valores digitales SI/NO, sino que queremos medir el valor de la luz que llega. Por eso usaremos entradas ANALÓGICAS. Las podemos encontrar en nuestra placa como A0, A1…

El esquema del montaje será muy parecido al montaje básico del pulsador (que para eso lo hemos explicado…)



Como ves, la principal diferencia es que conectamos el LDR a un pin analógico.

Además vamos a hacer otra cosa interesante con este nuevo sketch. Vamos a visualizar los valores que obtengamos del sensor en nuestro ordenador a través del puerto USB. Para ello usaremos el MONITOR SERIAL del menú HERRAMIENTAS de nuestro IDE. Si, es bastante feo, pero es el que hay. Las instrucciones básicas que debemos conocer del monitor son:

Serial.begin(9600)                     inicia la comunicación con el monitor a 9600 bits/seg

Serial.print(“Hola Mundo!”)        muestra una línea con Hola mundo

Serial.println(Valor)                   muestra en la misma línea el valor de una variable

Con esto nos apañamos..., de momento.

Vamos con el ejemplo:


// Midiendo la cantidad de luz con un LDR

int LDR_pin = 2;                                   // vamos a leer los valores del pin 0

int LDR_val = 0;                                    // definimos la VARIABLE LDR_val y le damos el valor inicial = 0

void setup() {

Serial.begin(9600);                              // iniciamos el monitor serial.

}                                              

void loop()

{
LDR_val = analogRead(LDR_pin);     // leemos el valor que da el LDR.

Serial.print("LDR = ");                          // Imprimimos el texto LRD= en una línea del monitor

Serial.println(LDR_val);                       // en la misma línea, a continuación, el valor leído por el sensor

delay(1000);                                          // Paro 1 segundo. Vuelvo al bucle, mido, imprimo, espero….bucle
}

Genial, ya sabemos presentar en nuestro ordenador datos medidos con nuestra placa arduino. Ahora, además de leerlos y presentarlos, vamos a procesarlos.

Lo inmediato que se nos ocurre a todos es que, a partir de un determinado valor de lectura, hagamos algo. Por ejemplo podríamos encender automáticamente un led cuando el valor de la luz sea inferior al que nosotros fijemos. El esquema electrónico sería:




Usando el mismo ejemplo anterior, vamos a añadir unas líneas de código. Sólo comentaremos las líneas añadidas.

// Encendido automático de un LED en función de la luz                          

int LED_pin=13;                                    //conectamos el LED en el pin 13
int LDR_pin = 2;              
int LDR_val = 0;             

void setup() {

pinMode(LED_pin,OUTPUT);             // LED del pin configurado como SALIDA
Serial .begin(9600);
}

void loop()
{
LDR_val = analogRead(LDR_pin);
Serial.print("LDR = "); 
Serial.println(LDR_val);

if (LDR_val>=20)                                   // Si hay luz, valor mayor de 20:
{
   digitalWrite(LED_pin, LOW);           // Apago el LED
}
else if (LDR_val<20)                             // Si no hay luz, si su valor es menor que 20…
{
   digitalWrite(LED_pin, HIGH);          // Encendemos el LED
delay(1000);
}
}


el sensor de temperatura

Si hemos puesto un sensor de luz y nos ha funcionado, lo mismo podemos hacer con uno de temperatura. También está compuesto por una resistencia variable que variará su valor en función de la temperatura. También podremos monitorizar los valores, procesar los datos…

Todo eso corre de tu cuenta… A otra cosa!


librerías

Las librerías son pequeños programas que nos permiten usar fácilmente elementos complejos que conectamos a nuestra placa. Arduino ya cuenta con muchas de ellas. Las puedes encontrar en el directorio libraries, y aparecen en el menu ejemplos.

Cuando queramos conectar algo más “éxótico” que una LDR, como un sensor complejo, una pantalla lcd o una controladora de motores, probablemente tengamos que instalar también una librería para controlarlo.


El procedimiento es sencillo. Lo primero es obtener la biblioteca del componente. Si lo hemos adquirido en una tienda seria, y hay muchas, normalmente lo podremos descargar desde la hoja de descripción del producto, junto con la datasheet del mismo. También las podemos descargar de  Github o de Arduino Playground.

Una vez descargado el archivo zip, lo descomprimimos en la carpeta libraries de nuestro Arduino, nos aseguramos que la carpeta contenga los caracteres correctos y reiniciamos el IDE. Cuando ahora mi programa llame al principio a la librería que hemos instalado con la instrucción #include, veremos que esta llamada aparece en naranja, señal de que la ha reconocido correctamente.

#include <Wire.h>


…ya te dijimos que estaba fácil

- Copyright © Robótica y Arduino en la ESO - Skyblue - Powered by Blogger - Designed by Johanes Djogan -