Embed Size (px)
Citation preview
1. ¿Qué es Arduino?
2. Modelos de Arduino
3. Primer programa: parpadeo de un LED 3.1. Preparar la conexión
3.2. Estructura básica de un programa
3.3. Cargando un ejemplo
3.4. Conexión del hardware al Arduino
4. Segundo programa: entradas y salidas digitales
5. Tercer programa: entradas analógicasy salidas PWM
1. ¿Qué es Arduino?Arduino es una placa programable con entradas y salidas digitales y analógicas,cuyo bajo coste la hace ideal para iniciarse en automatización o realizar pequeñosproyectos en electrónica y robótica. Esto significa que disponemos de un pequeño“autómata”, capaz de recibir información del entorno (sensores) y realizar acciones(actuadores, motores…), según un programa que introducimos con un ordenador, y quepuede ejecutar de forma autónoma.La placa programable está basada en microcontroladores de ATMEL (ATmega168,ATmega328, ATmega2560, etc.) que llevan precargado un gestor de arranque oBootloader para poder volcarles por el USB del ordenador el programa directamentedesde su entorno de programación (IDE de Arduino).Arduino es, por tanto, el conjunto de una placa programable basada en micros de ATMEL,que lleva un Bootloader precargado y que se programa de forma sencilla desde unentorno de programación o IDE.
2. Modelos de ArduinoExisten multitud de modelos Arduino disponibles, lo que puede ser un poco confuso paralos nuevos usuarios. A la hora de elegir lo normal es que nos fijemos en la cantidad deentradas y salidas que tiene, especialmente las analógicas dado que son las quehabitualmente restringen nuestro proyecto. En la siguiente tabla podéis ver los modelosde Arduino más habituales, con sus características más importantes y un precio dereferencia. Disponéis de un listado completo de los distintos modelos y revisionesen http://es.wikipedia.org/wiki/Arduino .
Modelo I/Odigitales
Entradasanalógicas
SalidasPWM
UART MemoriaFlash
MicroATMEL
Precio€
Uno r3 14 6 6 1 32 KB ATmega328 26Leonardo 20 12 7 1 32 KB ATmega32u4 24Mega 2560 54 16 14 4 256 KB ATmega2560 50
Mini 05 14 6 8 1 32 KB ATmega328 19
3. Primer programa: parpadeo de un LED
Para poder probar un programa en Arduino necesitamos una placa Arduino UNO o similar
y el Entorno de Desarrollo Integrado (IDE, en inglés) de Arduino correctamente instalado.
3.1. Preparar la conexiónEn primer lugar, conectamos nuestra placa Arduino mediante un cable USB A-B, deltipo que se emplean habitualmente para conectar impresoras. De momento no hace faltala conexión de alimentación o cable adicional, para realizar la programación es suficienteúnicamente con el USB.
A continuación abrimos el entorno IDE de Arduino:
Seleccionamos el modelo de placa que estemos empleando:
Seleccionamos el puerto de comunicación al que esta conectado:
•En Windows será algo tipo COM1, COM3…•
Ya tenemos la conexión configurada y lista para realizar la carga de nuestro primerprograma.
3.2. Estructura básica de programaEn el IDE de Arduino estandard los programas tienen siempre la siguiente estructura:
123456789
//Zona DECLARACIONES void setup() { // Zona funcion SETUP} void loop() { // Zona funcion LOOP }
Donde cada parte tiene la siguiente función:
•Zona declaraciones: En esta parte se declaran variables, funciones, objetos, y estructuras.•Funcion setup: Esta función se ejecuta cada vez que se enciende la placa de Arduino, o se pulsa la tecla Reset. Realiza funciones de inicialización de periféricos, comunicaciones, variables, etc.•Funcion loop: Esta función se ejecuta contínuamente. Realiza el grueso de tareas del autómata.
Esta configuración (una función de setup y un bucle que se ejecuta contínuamente) eshabitual en la programación de automatismos, siendo la única que permite el IDEestandard de Arduino. Otras configuraciones son posibles mediante el empleo de otrosIDE.
3.3. Cargando un ejemploPara probar el funcionamiento de nuestro montaje vamos a emplear uno de los ejemplosincluidos en el IDE de Arduino.
Se puede aprender mucho leyendo los ejemplos, es muy recomendable echar un vistazo a todos.
Seleccionamos el ejemplo Basics/Blink, y aparecerá un código similar al siguiente:
123456789101112
int led = 13; //asignar variable led como 13 void setup() { pinMode(led, OUTPUT); //definir pin 13 como salida } void loop() { digitalWrite(led, HIGH); // encender LED delay(1000); // esperar un segundo digitalWrite(led, LOW); // apagar LED delay(1000); // esperar un segundo}
Este ejemplo enciende y apaga un LED cada segundo. La función de cada linea estácomentada a la derecha. El LED empleado está integrado en muchas de las placas deArduino (UNO, MEGA, etc) conectado físicamente al PIN 13.
No os olvidéis del PIN 13 a la hora de realizar vuestros programas. Resulta de gran ayuda a la hora de debugear vuestros programas.
Finalmente, pulsamos en el botón remarcado para compilar y enviar la programación anuestra placa Arduino. Tras unos segundos, el IDE compilará el programa y la pantalladebería ser similar a la siguiente:
Tras unos parpadeos, la placa empezará a ejecutar el programa, encendiendo yapagando el LED.
3.4. Conexión del hardware al Arduino
Material necesario:
•Una placa Arduino•Una resistencia de 220Ω•Un diodo LED•Una Protoboard
Debemos lograr mediante el programa de nuestro Arduino, encender y apagar un LED que conectaremos a una salida mediante una resistencia que nos regulará la intensidad que debe llegar al diodo. Las placas de Arduino ya llevan incorporada una resistencia de 220Ω en su salida 13 y podríamos omitirla si utilizáramos ésta.Ahora vamos a mostrar también cómo calcular el tipo de resistencia que debemos poner en cada momento, utilizaremos la salida 12 como ejemplo.En primer lugar os dejo una imagen del esquema eléctrico del circuito:
Debéis poner especia atención en polarizar el LED correctamente, en nuestro caso, como la tensión de salida de la placa de Arduino es de 5v, la tensión de nuestro LED rojo es de1,8v y la corriente que debe pasar es de 15 mA nos quedará la siguiente fórmula:
Por lo que hemos elegido una resistencia de 220Ω, la más cercana a ese valor existente en el mercado.
Ahora solo nos queda calcular la potencia de dicha resistencia, recordando que P=VxI tenemos que
P = (5-1,8) x 0,015 = 0,048wEs decir como mínimo debe ser de 48mW por lo que nos vale la más estándar de las resistencias, la de 1/4 de watio.
El esquema eléctrico nos quedaría de la siguiente manera:
Debemos modificar el programa anterior, cambiando la variable led por 12:
123456789
101112
int led = 12; //asignar variable led como 12 void setup() { pinMode(led, OUTPUT); //definir pin 12 como salida } void loop() { digitalWrite(led, HIGH); // encender LED delay(1000); // esperar un segundo digitalWrite(led, LOW); // apagar LED delay(1000); // esperar un segundo}
Después de compilar y enviar el programa, el led externo conectado a la salida digital 12 debería de parpadear cada segundo.
4. Segundo programa: entradas y salidasdigitales
En este tutorial de Arduino, vamos a aprender a configurar una entrada digital a la que
conectaremos un pulsador y, con lo aprendido sobre el LED en el anterior tutorial, nos
permitirá controlar el encendido y apagado del diodo.
Material necesario para el proyecto:
•1 placa Arduino.•1 protoboard.•1 diodo LED.•1 resistencia 220Ω.•1 resistencia 10K.•1 pulsador.
En este proyecto, deberemos interpretar en nuestro programa la lectura de una entrada digital, y en base a su lectura, activaremos, o no, una salida digital a la que conectamos un diodo LED, es un ejemplo sencillo, pero que nos permite aclarar un concepto muy importe sobre las entradas digitales, las resistencias de Pull-Up o Pull-Down.¿Qué son las resistencias de Pull-Up o Pull-Down?En nuestro Arduino, las entradas digitales se interpretan de la siguiente manera:
•1 (lógico) = Hight = +5v•0 (lógico) = Low = 0v
¿Esto quiere decir? Que si tenemos una tensión de +5v aplicada a una entrada, Arduino nos la interpretara como un 1 (hight) sin lugar a dudas, pero no es así al contrario, si nosotros dejamos dejamos de aplicar esa tensión a la entrada digital, es posible que recibamos algo de ruido del circuito y que Arduino no nos lo interprete como un 0 (low) porlo que colocamos una resistencia entre la entrada y masa (GND) que derive estos ruidos asegurándonos una señal limpia y sin posibles errores, a la resistencia que se conecta a masa se le llama PULL-DOWN.
De igual manera, si tuviéramos la necesidad de mantener un 1 lógico en una entrada mientras el circuito está en reposo, se le puede aplicar una resistencia entre la entrada y +5v para asegurarnos que le llega suficiente tensión como para que sea interpretada correctamente por nuestro Arduino, a esta última se le denomina PULL-UP.
Aquí podéis ver como se conectaría la resistencia en un circuito básico de 0 o 1 en la entrada 8 de Arduino.
Una vez conocido esto, el resto del circuito no tiene misterio, deberemos colocar el LEDcorrectamente polarizado con su resistencia, y el pulsador con una resistencia de PULL DOWN de 10KΩ a masa para cuando esté en reposo, de manera que cuando pulsemos el botón, llegue una tensión 5v a la entrada 2 de Arduino y éste lo interprete como un 1 lógico, a partir de aquí el programa hará el resto para proporcionarnos la tensión de salida que activará el diodo LED.Las conexiones en nuestra protoboard nos quedarían de la siguiente manera:
Para observar con más detalle las conexiones entre componentes se puede observar el siguiente esquema eléctrico:
Como se puede observar, los pulsadores electrónicos parecen llevar cuatro patillas, pero en realidad sólo son dos muy largas que salen por los laterales del pulsador para facilitar las conexiones, de manera que si lo colocamos y el LED se enciende continuamente, es muy posible que lo hayamos conectado mal, si tenéis un polímetro, colocarlo en modo continuidad y aseguraos de la posición correcta.
123456789
10111213141516171819202122232425262728293031323334353637383940
/* Tutorial #0002 Arduino Academy - E/S DIGITALES En este proyecto encenderemos un LED conectado al pin digital 12 cuando presionemos el pulsador asociado al pin digital 2. Este proyecto es de dominio público */ // Variables estáticasint pinBoton = 2; // Declaramos la variable pin del Botónint pinLed = 12; // Declaramos la variable pin del Led // Variables dinámicasint estadoBoton = 0; // Variable para estado del botón void setup() {// Inicializa el pin del LED como salida:pinMode(pinLed, OUTPUT);// Inicializa el pin del botón como entrada:pinMode(pinBoton, INPUT);} void loop(){// Lee el valor del pin del botón y lo almacena// en la variable estadoBotonestadoBoton = digitalRead(pinBoton); // Chequea si el botón está pulsado:if (estadoBoton == HIGH) {// Si es así, enciende el LED:digitalWrite(pinLed, HIGH);} else {// Si no, lo mantiene apagado:digitalWrite(pinLed, LOW);}}
Como veréis algunas instrucciones ya han sido vistas en el anterior tutorial, así que nos centraremos en aquellas que son nuevas para nosotros.En primer lugar podemos observar que antes del setup hemos declarado unas variables globales, y ademas las hemos organizado en estáticas y dinámicas:
// Variables estáticasint pinBoton = 2; // Declaramos la variable pin del Botónint pinLed = 12; // Declaramos la variable pin del Led
// Variables dinámicasint estadoBoton = 0; // Variable para estado del botón
Para definir una variable imaginemos que queremos comprar una recipiente en el que vamos a guardar algo, y depende de lo que queramos introducir, tendrá que ser de una manera o de otra, si es líquido, no puede ser de cartón, si es algo pesado no puede ser frágil… Eso es una variable, un lugar en el que almacenaremos algo para utilizar en nuestro programa, y si no las declaramos antes de utilizar, es como si no hiciéramos hueco en nuestra despensa para guardarlas, otra característica es que su inicialización nosiempre es obligatoria, pero es recomendable, esto es como meter una pieza de cada producto que vayamos a guardar en nuestras cajas, en este caso les hemos asignado un valor desde el principio por las necesidades del programa.
¿Y como le digo si es de cristal o de cartón?
Definiendo el tipo de variable a utilizar, en este programa hemos utilizado las de tipo int pero existen muchas más dependiendo de nuestras necesidades que iremos descubriendo en los siguientes programas, de momento nos quedamos con la siguiente:
•Variable de tipo int: Almacena números enteros con un rango de -32768 a 32767Al principio de la explicación, las he descrito en primer lugar como variables globales, estoes que al estar fuera de todo ciclo, pueden ser utilizadas a lo largo de todo el programa ahorrándonos mucho código, en ejemplos posteriores veremos otros lugares donde declararlas.
Y por último, en lo que respecta a las variables, las he organizado como estáticas, aquellas que serán constantes en nuestro programa, y dinámicas, aquellas que variaremos su valor en algún lugar del programa
Como novedad, podemos ver que en lugar de asignar un valor numérico en la instrucción pinMode para decirle el pin sobre el que queremos trabajar, le hemos asignado una variable, y a la hora de interpretar el programa, este utilizara lo que hayamos elegido introducir en nuestro recipiente, en este caso el número entero 12 para la salida del LED yel número entero 2 para la entrada del pulsador.
void setup() {// Inicializa el pin del LED como salida:pinMode(pinLed, OUTPUT);// Inicializa el pin del botón como entrada:pinMode(pinBoton, INPUT);}Para explicar el loop, lo dividiré en dos partes, en primer lugar, tenemos que cada vez quese ejecute el ciclo loop, lo primero que va a hacer es almacenar en nuestra variable dinámica de tipo int “estadoBoton”, la lectura del pin 2 de nuestro Arduino.
estadoBoton = digitalRead(pinBoton);Y ahora llega algo nuevo, el ciclo if… else, este ciclo es un condicional básico en programación, lo que hace en nuestro programa es comprobar primero si nuestra variable estadoBoton está a 1 lógico, y, a continuación, con el resultado obtenido de esa comparación, elige un camino u otro, si es que sí, entonces encenderá el LED poniendo en HIGH, si es que no, entonces pondrá en LOW nuestra salida del LED apagándolo.
// Chequea si el botón está pulsado:if (estadoBoton == HIGH) {
// Si es así, enciende el LED:digitalWrite(pinLed, HIGH);}
else {// Si no, lo mantiene apagado:digitalWrite(pinLed, LOW);}
5. Tercer programa: entradas analógicas ysalidas PWM
En este nuevo proyecto vamos a aprender utilizar las entradas analógicas de nuestro pequeño Arduino Uno para utilizarla en dos ejemplos, primero variaremos la frecuencia deparpadeo de un diodo LED con un potenciómetro conectado a una entrada analógica y luego utilizaremos el mismo circuito para realizar una modulación del ancho de un pulso en una salida digital (PWM).
Material necesario para este proyecto:
•1 x Arduino Uno•1 x Diodo Led•1 x Resistencia 470 Ω•1 x Potenciómetro 1KΩ•1 x Protoboard•1 x Juego de cables
En este proyecto Arduino vamos a realizar dos ejemplos con un mismo circuito, la diferencia entre ellos la observaremos es el apartado de programación, en cuanto a hardware tenemos la novedad de este proyecto en el uso de un potenciómetro combinadocon una entrada analógica.
En este proyecto, vamos a utilizar el potenciómetro como un divisor de tensión, primero veamos como se conecta para que esto sea posible.
Como podemos ver, debemos colocar uno de los extremos a masa, otro a +Vcc y nuestra patilla central será nuestra tensión de salida regulable, esta salida será la que conectemosa Arduino y que variará de 0v a 5v dependiendo de la posición de nuestro potenciómetro.
Si estamos utilizando un Arduino Uno, las entradas analógicas vienen identificadas desde A0 hasta A5 como podemos ver en la siguiente imagen:
En cuanto a la salida, colocaremos la ya conocida configuración de LED más resistencia, pero deberemos tener algo en cuenta, para el primer ejemplo nos daría igual la salida digital a elegir, pero para el segundo es necesario que seleccionemos una salida con PWM, si tenéis un Arduino Uno, las salidas serán la 3, 5, 6, 9, 10 y 11 como se puede ver en la siguiente imagen:
Pero.. ¿Qué es el PWM?A menudo necesitaremos algo más que una señal de 0 o 1 en nuestros proyectos, para variar la velocidad de giro de un motor, para variar la intensidad con la que luce un diodo, para transmitir los grados de giro de un servo, etc..
Para todo esto, y mucho más, nos servirá el PWM, que emula una señal analógica a partirde una señal digital.
Las siglas PWM vienen de Pulse Width Modultation, o Modulación de Ancho de Pulso.
Lo que hace este tipo de señal es emitir, en lugar de una señal continua en nuestra salida,emite una serie de pulsos que podremos variar su duración pero con una frecuencia constante de aproximadamente 490Hz, de manera que la tensión promedio resultante, es directamente proporcional a la duración de estos dentro del rango de nuestro periodo, es decir, cuanto más juntos estén esos pulsos de +5v, mayor será la tensión promedio de nuestra salida, y cuanto más distantes sean estos, menor será dicha tensión:
La manera de controlar el nivel de salida en nuestro Arduino, la podremos ver en la sección de programación de este tutorial.
El montaje nos quedaría así en nuestra protoboard:
Aquí podemos ver en detalle el esquema eléctrico:
El circuito en si mismo es muy sencillo, pero en el apartado de programación podremos ver la versatilidad del mismo para diferentes aplicaciones:
El primer ejemplo que vamos a tratar es la adquisición de datos en la entrada analógica A0 para variar la frecuencia de parpadeo de un diodo LED conectado a una salida digital cualquiera, veamos el código al completo:
123456789
1011121314151617181920212223242526272829303132
/* Tutorial # 0003 Arduino Academy - Entrada analógica Funcionamiento de las entradas analógicas configurando el pin analógico A0 para tomar datos de una señal. Esta toma de datos es utilizada para variar la velocidad de parpadeo de un diodo LED conectado a la salida digital 9. Este proyecto es de dominio público. */ int pinSensor = A0; // Entrada para el potenciómetro.int pinLed = 9; // Seleccionamos pin para el Led.int valorSensor = 0; // variable para el valor del sensor. void setup() { // Declaramos el pin del Led como salida: pinMode(pinLed, OUTPUT);} void loop() { // Leemos el valor del sensor y lo almacenamos: valorSensor = analogRead(pinSensor); // encendemo el diodo LED: digitalWrite(pinLed, HIGH); // Detenemos el programa durante <valorSensor> milisegundos: delay(valorSensor); // Apagamos el diodo Led: digitalWrite(pinLed, LOW); // Detenemos el programa durante <valorSensor> milisegundos: delay(valorSensor);}
En este programa tenemos como novedad la siguiente instrucción:
1analogRead(pinSensor)Esta instrucción nos permite leer cualquier sensor que conectemos al pin analógico establecido en “pinSensor”, por defecto, nuestra placa Arduino nos realizará una conversión analógico-digital para toda señal (40mA máximo) de 0v a 5v con una resolución de 10 bit, lo que nos da 210 (1024) valores de referencia para nuestro programa, siendo 0 en 0v y 1023 en +5v, en posteriores ejemplos veremos como ese rango de tensión en el que se realizan las mediciones se puede variar para que, por ejemplo, empiece a lanzarnos valores a partir de 2,2v.Con esto, y observando un poco el programa, podemor ver que el intervalo entre encendido y apagado de nuestro diodo LED podrá variar entre 0 y 1023 milisegundos, si quisiéramos aumentar más el tiempo de los intervalos podríamos aplicar alguna operaciónmatemática al valor de nuestro sensor, por ejemplo, si añadiéramos la línea de código quese puede observar debajo de la toma de datos del sensor obtendríamos un incremento del tiempo cuatro veces mayor:
123
// Leemos el valor del sensor y lo almacenamos:valorSensor = analogRead(pinSensor);valorSensor = valorSensor*4;
Sin variar el circuito, vamos a introducir un nuevo código para realizar un ejemplo diferente, en este proyecto, nuestro diodo LED variará su intensidad lumínica en función del valor que esté aportando el potenciómetro a nuestra entrada analógica, esto es el llamado efecto fading (desvanecimiento), puede observarse que se ha elegido la salida número 9, ya que esta sí que es compatible con la opción PWM como se explica algo más arriba.
Veamos el código al completo:
123456789
10111213141516171819202122232425
/* Tutorial Arduino # 0003 - Efecto Fading En este tutorial, mostramos como se desvanece un LED en función del valor recogido en un entrada analógica. Este proyecto es de dominio público. */ int pinSensor = A0; // Entrada para el potenciómetro.int pinLed = 9; // Seleccionamos pin para el Led.int valorSensor = 0; // variable para el valor del sensor. void setup() { pinMode(pinLed, OUTPUT); // Establecemos el pin como salida.} void loop() { // Leemos el valor del sensor y lo almacenamos: valorSensor = analogRead(pinSensor); // Establecemos el valor analógico para la salida PWM analogWrite(pinLed, valorSensor / 4); // Detenemos el programa durante 30 milisegundos: delay(30);}
Podemos observar una nueva instrucción:
1analogWrite(pinLed, valorSensor / 4);Esta será la instrucción que nos permitirá emular una señal analógica a partir de una digital en nuestros circuitos, como explicaba algo más arriba.
El rango de salida de esta instrucción varia de 0 a 255, siendo 0 = 0v y 255 = 5v, por lo que es tan sencillo como introducir un valor determinado para la tensión de salida que nosotros queramos conseguir, si quisiéramos conseguir 2,5v el valor a asignar sería 127.
Así que lo único que debemos hacer es transformar mediante una simple operación
matemática la señal tomada en nuestro potenciómetro para adaptarla a la salida PWM.
Como hemos visto en el ejemplo anterior, los niveles de entrada son de 0 a 1023, y si los niveles de salida, deben ser de 0 a 255… Os dejo a vosotros la deducción, y la línea de código por si no caéis en cuenta.
1analogWrite(pinLed, valorSensor / 4);Esta es una manera algo tosca para realizar esta conversión, más adelante veremos como hay una instrucción que hace esto por nosotros.
Para ver más tutoriales sobre Arduino: www.arduteka.com
