ARDUINO

9 788426 721457

Iniciación a Arduino UNO Miguel Pareja Aparicio

Iniciación a Arduino UNO

Primera edición, 2014

© 2014, Miguel Pareja Aparicio

© 2014 MARCOMBO, S.A. www.marcombo.com

Diseño de la cubierta: NDENU DISSENY GRÀFIC Corrección: Raquel Sayas Lloris «Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra solo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de Derechos Reprográficos, www.cedro.org) si necesita fotocopiar o escanear algún fragmento de esta obra». ISBN: 978-84-267-2145-7

Índice Introducción ............................................................................................. 1 Capítulo 1. ¿Qué es arduino? ..................................................................... 3 1.1 Introducción ..................................................................................... 3 1.2 Software libre: qué es y qué me hace falta ...................................... 3 1.3 Hardware libre: ¿existe? .................................................................. 5 1.4 Pero ¿qué es arduino uno? ............................................................... 7 1.5 ¿Qué necesito para empezar?........................................................ 10 1.6 Programar: ¿qué necesito saber? .................................................. 15 1.7 Actividades propuestas .................................................................. 20 Capítulo 2. Primeros pasos ...................................................................... 23 2.1 Introducción ................................................................................... 23 2.2 Instalación de software y preparación de Arduino ........................ 23 2.3 Entorno Arduino ............................................................................. 28 2.4 Primer programa y práctica con Arduino ....................................... 30 2.5 Monitorización puerto Serial0........................................................ 35 Ejercicio resuelto 1: comunicación serial0 .............................. 36 2.6 Actividades propuestas .................................................................. 38 Capítulo 3. Entradas y salidas digitales .................................................... 39 3.1 Introducción ................................................................................... 39 3.2 Pines de entrada y salida digitales en Arduino .............................. 39 3.3 Montajes i: fundamentos de electrónica........................................ 41 3.4 Montajes ii: protoboard o placa de prototipos .............................. 42 3.5 Conexionado de leds como salida .................................................. 45 Ejercicio resuelto 2: semáforo ................................................. 48 3.6 Conexionado de pulsadores como entrada .................................... 50 Ejercicio resuelto 3: conmutada .............................................. 53 Ejercicio resuelto 4: semáforo controlado por un pulsador .... 55 3.7 Actividades propuestas. ................................................................. 59 Capítulo 4. Ampliación entradas y salidas digitales .................................. 61 4.1 Introducción ................................................................................... 61 4.2 Conectando sensores a las entradas digitales ............................... 61 Ejercicio resuelto 5: comprobación interruptor de inclinación y reed................................................................ 64 Ejercicio resuelto 6: contador.................................................. 67 4.3 Conectando más receptores a las salidas digitales ........................ 72 Ejercicio resuelto 7: led multicolor .......................................... 76

Ejercicio resuelto 8: control iluminación tras apertura de puerta ................................................................................. 78 4.4 Actividades propuestas .................................................................. 82 Capítulo 5. Salidas digitales PWM ............................................................ 85 5.1 Introducción ................................................................................... 85 5.2 Modulación por ancho de pulso (señal PWM) ............................... 85 Ejercicio resuelto 9: regulación iluminación led ...................... 87 5.3 Variar la velocidad de un motor de continua ................................. 88 Ejercicio resuelto 10: control de velocidad motor dc con dos pulsadores.................................................................. 89 Ejercicio resuelto 11: motor con inversión del sentido de giro................................................................... 92 5.4 Control de servomotores ................................................................ 96 Ejercicio resuelto 12: control serie posición servo ................... 99 5.5 Pines 1 y 2 .................................................................................... 100 5.6 Actividades propuestas ................................................................ 100 Capítulo 6. Entradas analógicas ............................................................. 101 6.1 Introducción ................................................................................. 101 6.2 Las entradas analógicas de Arduino ............................................ 101 Ejercicio resuelto 13: lectura potenciómetro ........................ 102 6.3 Medida de temperatura ............................................................... 105 Ejercicio resuelto 14: medida de temperatura con LM35D ............................................................................ 107 Ejercicio resuelto 15: medida de temperatura con TMP36 ............................................................................ 109 Ejercicio resuelto 16: medida con termistor. ......................... 109 6.4 Medida intensidad luminosa ........................................................ 111 Ejercicio resuelto 17: medida de resistencia LDR .................. 112 Ejercicio resuelto 18: interruptor crepuscular ....................... 114 Ejercicio resuelto 19: control de velocidad motor dc con potenciómetro ................................................................ 116 6.5 Actividades propuestas ................................................................ 117

Introducción El presente libro contiene la información básica para iniciarse en el mundo de Arduino UNO, desde los fundamentos teóricos necesarios pasando por los fundamentos de programación para llegar hasta las nociones básicas de electrónica para su montaje. Se ha estructurado en seis capítulos, de los cuales el primero pretende dar un vistazo rápido a todo lo relacionado con Arduino, así como el material mínimo para iniciarse. El segundo se centra en el apartado del software necesario para realizar los programas que modelarán su funcionamiento. Del tercero hasta el quinto, se centran en las distintas posibilidades que ofrecen sus conexiones digitales. El sexto sirve para describir la utilización de las entradas analógicas. La pretensión es que sea una obra práctica por lo que los conceptos teóricos se ven de forma breve y directa sin entrar en rodeos, y por ello se acompañan de ejercicios resueltos para que puedan ser inmediatamente implementados siguiendo las pautas indicadas. El texto se ha escrito pensando en que sea «para todos los públicos», para usuarios noveles, con conocimientos de electrónica o no, o conocimientos de programación o no. Simplemente se requerirá un nivel de usuario de ordenador y será capaz de operar con Arduino. En cosecuencia se ha estructurado de forma secuencial la introducción de conocimientos o fundamentos a tener en cuenta. Ello queda patente en que, conforme vaya avanzando entre las páginas, el número de códigos y montajes a realizar irá en aumento. Lógicamente el que tenga fundamentos de electrónica o programación podrá avanzar más rápido que el que no los tiene. Pero si no es así, no le será un impedimento si sigue cada uno de los capítulos. Su estructura secuencial permite que conforme vaya avanzando tendrá que asimilar nuevos conceptos y montajes, sin olvidar los vistos en páginas anteriores, de tal forma que se puede estructurar en varias sesiones, según capítulos, para ser utilizado en cursos de introducción a Arduino, con un tiempo limitado. Por ello, cada capítulo dispone de ejemplos que permitirán asimilar los conceptos vistos. Además, al final de los capítulos se incluyen una serie de

1

Introducción actividades propuestas para que sean realizadas por los alumnos para verificar la asimilación de los conceptos vistos previamente. Esta obra es la primera de una serie que pretende centrarse en el mundo de Arduino UNO, puesto que se trata de un mundo bastante amplio y en continua evolución. Dedicar un único libro puede tener un tamaño considerable y ello lo hace menos práctico para su manejo, por lo que al distribuirlo por niveles y aplicaciones, el usuario puede escoger el que más se adapte a sus necesidades.

2

1. ¿Qué es Arduino? 1.1 Introducción Este primer capítulo pretende dar a conocer qué es Arduino, así como las herramientas y material necesario para empezar a trabajar. Siguiendo una de las principales filosofías asociadas a Arduino, el usuario o técnico debería empezar a trabajar con este dispositivo con conocimientos básicos de electrónica y con un nivel de usuario de programación. En este primer capítulo se va a presentar esta placa de circuito impreso y se incluirán los fundamentos de programación a tener en cuenta. Se incluyen a modo aclaratorio algunos conceptos sobre el término libre asociado al hardware y al software. Los conceptos puramente electrónicos se irán tratando a lo largo del texto. En los próximos capítulos se irán viendo en más detalle cada uno de los componentes según sean necesarios para los montajes mostrados y propuestos. La estructura de este capítulo es distinta a los próximos capítulos, ya que lo hemos enfocado como una serie de preguntas a las cuales se les ha intentado dar respuesta con la máxima claridad y con la mayor brevedad posible. Por el contrario, los próximos capítulos serán mucho más prácticos.

1.2 Software libre: qué es y qué me hace falta Que una aplicación de software sea libre indica que se puede usar, distribuir, modificar y redistribuir, siempre y cuando la nueva aplicación creada sea redistribuida con la misma licencia, es decir, continúe siendo libre. Para ser libre también debe ir acompañada de su código fuente. Al acceder a la página web, en la sección de descargas, es fácil encontrar la siguiente información: la versión ejecutable y estable (totalmente funcional sin errores lista para ser usada), la versión beta o de prueba (añade nuevas funcionalidades pero no asegura que esté libre de errores) y código fuente (source code). 3

1. ¿Qué es Arduino? Cuando se habla de software libre se suele confundir con el concepto de aplicación gratuita (freeware), la cual se distribuye gratuitamente, y en ocasiones se ofrece el código fuente (aunque no suele ser usual que lo acompañe), y en este último caso se denomina de código abierto. Además la aplicación suele mantener el copyright del autor. Asimismo una variación de las denominadas como aplicaciones gratuitas es el shareware, que consiste en versiones limadas de un software comercial. Suelen ser: las limitadas en el tiempo (denominadas también trial) o limitadas en alguna de sus características (denominadas también de demostración o demo). En consecuencia cuando se habla de shareware, se trata de una aplicación gratuita pero con algunas restricciones. Volviendo al software libre, dichas aplicaciones utilizan la denominada licencia GPL (General Public License o licencia pública general). Se trata de una licencia creada por la Free Software Foundation a mediados de los años ochenta, y orientada principalmente a proteger la libre distribución, modificación y uso de software, es decir a favorecer el uso de software libre. Si se lee el primer punto de una licencia GPL que acompaña a las aplicaciones libres, queda patente el fin principal de dicha licencia. A continuación se muestra una traducción de dicho punto: Usted puede copiar y distribuir copias literales del código fuente del programa, según lo has recibido, en cualquier medio, siempre y cuando, y de forma adecuada y bien visible, publique en cada copia un anuncio del copyright adecuado y un repudio de garantía, mantenga intactos todos los anuncios que se refieran a esta licencia y a la ausencia de garantía, y proporcione a cualquier otro receptor del programa una copia de esta licencia junto con el programa. Puede cobrar un precio por el acto físico de transferir una copia, y puede, según su libre albedrío, ofrecer garantía a cambio de unos honorarios. En el caso particular de Arduino, se trata de algo físico, que en un principio no es software libre, pero sí se tiene en cuenta que se necesitan algunas aplicaciones para realizar la programación. El software necesario se puede obtener directamente de la siguiente página web: http://www.arduino.cc/en/Main/Software

4

Iniciación a Arduino UNO Tal y cómo se indica, se trata de software de código abierto, y se puede descargar el código fuente o la aplicación funcional para diversas plataformas (Windows, Linux o Mac). Está escrito en Java, por lo que se necesitará tenerlo instalado, y basado en Processing (entorno de programación), avr-gcc (lenguaje de programación) y otros programas también de código abierto.

1.3 Hardware libre: ¿existe? Si tomamos como referencia el software libre (que permite: libertad de uso, de estudio, modificación y distribución, y redistribución con las mejoras), estas libertades no pueden ser aplicadas directamente sobre el hardware libre, ya que se trabaja con partes físicas que cuestan un cierto desembolso económico y parte de ello es lo que ha provocado que sufra cierto retraso respecto al software libre. Así pues, generalizando se habla sobre hardware libre o abierto a la documentación asociada a los diseños informáticos o electrónicos. De tal forma que cualquiera pueda acceder a dicha documentación y crear sus propios diseños. Ahora bien, si se utiliza una aplicación (libre, gratuita o de pago) para realizar el diseño y se distribuyen los ficheros necesarios, no solo para crear la parte física (como podría ser crear la placa de circuito impreso) sino para modificar el diseño y su documentación asociada, entonces se encuentra ante un hardware abierto o libre. Es decir, el hardware libre ofrece las mismas cuatro libertades que el software libre pero aplicado a los esquemas del hardware. El hardware libre se puede clasificar en: • El hardware libre estático, cuando el esquema del circuito electrónico está formado por dispositivos electrónicos concretos, cuya funcionalidad está determinada. • El hardware libre reconfigurable es cuando el circuito que representa el esquema tiene una estructura física concreta pero que permite modificar su funcionalidad mediante la programación de cierto dispositivo, por ejemplo: PLD, CPLD, FPGA o microcontrolador. Ambos tipos tienen sus ventajas e inconvenientes, siendo la primera la que puede presentar cierta simplicidad y funcionabilidad en función de la aplicación. Por el contrario, el segundo tipo presenta ventajas respecto a la funcionalidad

5

1. ¿Qué es Arduino? puesto que con un mismo circuito su funcionamiento puede cambiar realizando modificaciones mediante software. Por ejemplo, si yo encuentro un circuito que se adapta a mis necesidades, entonces puedo acceder al esquema y montarlo. El problema radicaría en si deseo realizarle alguna modificación. Además, el usuario debe realizar: la fabricación de la placa de circuito impreso, la compra de componentes, el montaje y la comprobación del diseño. Todo ello lleva asociado un coste tanto económico como de tiempo requerido. Por el contrario, al utilizar un circuito electrónico que contiene un microcontrolador con un mismo circuito puedo realizar distintas aplicaciones modificando la programación del mismo. En este segundo caso también se tendría que realizar el proceso de montajes y compra de materiales. Sin embargo, si se diseña una placa genérica que puede servir para multitud de aplicaciones, entonces dicha placa se puede fabricar a gran escala y en consecuencia el precio será menor. Arduino correspondería al denominado como hardware configurable, y aunque se puede descargar toda la documentación para fabricarse sus propias placas, puede resultar más económico el comprarla ya fabricada. En parte esta ha sido su gran ventaja, el comprar a un precio muy reducido (cuesta menos comprarla ya fabricada que construirse su propia placa de circuito impreso con todos los componentes y soldarlos) y que una vez recibida puede empezar a realizar alguna programación sencilla para verla en funcionamiento. Es decir, con unos conocimientos básicos o nulos de electrónica, y conocimientos de informática a nivel de usuario, puede estar realizando diseños o montajes. Además, si se dispone de ciertos conocimientos puede pasar a realizar sus propios diseños. Por ejemplo desde la siguiente página web puede acceder a todos los documentos para la realización de la placa de circuito impreso: http://arduino.cc/en/uploads/Main/arduino_Uno_Rev3-02-TH.zip Los ficheros que se descargan han sido realizados con la aplicación Eagle a partir de la versión 6.0 o superior. Además se indica que en el esquema se ha utilizado el patillaje del microcontrolador Atmega8, pero el esquema es el mismo para los modelos 168 o 328, porque la configuración de los pines es la misma.

6

Iniciación a Arduino UNO

1.4 Pero ¿qué es Arduino UNO? Arduino UNO (figura 1.1) es una placa de circuito impreso para el microcontrolador ATmega328. En la placa de circuito impreso ya se encuentra disponible todo el hardware necesario para que el usuario lo conecte vía USB al ordenador y pueda empezar a utilizarlo. Las principales características son: • Microcontrolador: ATmega328. • Tensión de operación: 5 voltios. • Tensión de entrada recomendada: de 7 a 12 voltios. • Tensión de entrada límite: de 6 a 20 voltios. • Pines de entrada y salida digitales: 14 (de los cuales 6 proporcionan una salida PWM). • Pines de entrada y salida analógicos: 6. • Corriente de cada pin de entrada y salida: 40 miliamperios. • Corriente para la salida de 3,3 voltios: 50 miliamperios. • Memoria Flash: 32 KB (ATmega328) de los cuales 0.5 KB son usados por el bootloader o gestor de arranque. • SRAM: 1 kilobyte. • EEPROM: 1 kilobyte. • Clok Speed: 16 megahercios.

Figura 1.1. Arduino UNO vista frontal (Cortesía de www.arduino.cc).

7

1. ¿Qué es Arduino? También existe otra versión de la misma placa, pero con la versión SMD (montaje superficial) del microcontrolador, (figura 1.2). Puede encontrar más información concreta de este microcontrolador en la siguiente página web: http://www.atmel.com/Images/doc8161.pdf

Figura 1.2. Arduino UNO versión SMD (Cortesía de www.arduino.cc).

Si observa las fotos de la figura 1.1 y 1.2, se puede apreciar en la serigrafía para qué sirve cada pin de conexión: • Power: alimentación o potencia. Sirve para obtener valores de tensión (3,3V y 5V) cuando se utiliza alimentación externa (Vin) o a través del puerto USB (limitación de corriente). • Analog in: entradas o salidas analógicas. Acepta valores de 0 a 5 voltios. • Digital: entradas o salidas digitales, tenga o no tensión a la salida. Se utiliza para entradas como sensores on/off o interruptores o pulsadores. Los pines indicados con el símbolo ∼ sirven para el control por ancho de pulso (PWM). • GND: terminal de valores de referencia para los valores de tensión. Nota: en los próximos capítulos se verá con mayor detalle la configuración y conexionado de Arduino.

8

Iniciación a Arduino UNO En resumen, las ventajas que ofrece Arduino son: •

Asequible: porque el coste de una placa es bastante económico, sobre todo si se compara con la fabricación propia u otros sistemas con microcontroladores.

•

Multi-plataforma: el software necesario sirve para trabajar en varios sistemas operativos: Windows, Linux y Mac. Sin embargo, otros sistemas con microcontroladores pueden estar limitados a un sistema operativo concreto.

•

Lenguaje de programación simple y directa: se basa en Processing (derivado de Java), que al tratarse de un lenguaje de alto nivel es fácil de utilizar por principiantes, pero por sus características es suficientemente flexible para usuarios avanzados.

•

Software de código abierto: al tratarse de software libre puede ser modificado o adaptado por programadores más experimentados para la mejora del entorno de programación.

•

Hardware de código abierto: al estar disponible los esquemas y con licencia libre, esto puede provocar que diseñadores de circuitos electrónicos incluyan nuevas versiones de los módulos, ampliándolo u optimizándolo.

Aunque este texto se centra en el Arduino UNO, están disponibles otras placas con algún cambio o ampliación, también disponibles para su compra, por ejemplo: •

Arduino MEGA: más potente, con más pines y más memoria, pero también más caro y más grande.

•

Arduino Bluetooth: incorpora en la misma placa un módulo para la transmisión por bluetooth hasta 100 metros.

•

Arduino Pro: versión de Arduino UNO más compacta y robusta para montajes portátiles, con todos los componentes de montaje en superficie y sin conectores para las entradas y salidas, lo cual permite reducir su espesor.

•

Arduino Mini: versión en miniatura del Arduino UNO con microcontrolador ATmega168, pero con menor memoria y transmisión del programa más lenta.

•

Arduino Nano: versión del Arduino Mini con pines para ser incluida en una placa de prototipos.

9

1. ¿Qué es Arduino? •

Arduino Pro Mini: versión mejorada del Arduino Mini, con mayor memoria para programa al incluir el Atmega 328.

Otra de las ventajas de Arduino respecto a otros sistemas con microcontroladores es la capacidad de colocar o disponer de placas o módulos que le añaden mayores funcionalidades con una conexión prácticamente instantánea. Son los denominados como shield. Por ejemplo, como algunas de las funcionalidades para comunicaciones: conexión de red (Ethernet) o inalámbrica (XBEE). Aunque como el objetivo del presente libro es a modo de iniciación no se verán en el presente texto.

1.5 ¿Qué necesito para empezar? Una buena forma de adentrarse en el mundo de Arduino es el recurrir a la compra de kits, que no son más que una placa Arduino ya montada con una serie de complementos. En algunos casos se acompaña de manuales o referencias digitales para que el usuario realice de forma guiada una serie de pasos y así aprenda los conceptos de montaje y programación. Además se suele vender en formato más económico puesto que en un único pedido se podrá disponer de todo el material necesario para la realización de los montajes básicos sobre Arduino. Para los aficionados a la electrónica que ya disponen de algunos componentes, podrán adquirir solo la placa de Arduino que le interese. En este punto, será el usuario quien realice la selección de qué comprar y dónde comprar, aunque es recomendable para iniciarse el recurrir a una serie de kits que dispondrán de un poco de todo y permitirán la realización de varios montajes. Después ya irá aumentando las adquisiciones y el material más específico según las necesidades de los diseños que vaya realizando. Los componentes básicos, con el Arduino incluido o no, que se van a necesitar son los siguientes:

10

•

Módulo Board o placa de prototipos, de 400 pines.

•

Cables y/o jumper. También hay cajas que tienen cables de distintas longitudes para el montaje en la placa de prototipos.

•

Resistencia/s variable, potenciómetro, principalmente de 10 k.

Iniciación a Arduino UNO

Figura 1.3. Kit básico de Arduino (cortesía de www.electan.com).

•

Led RGB (que tiene 3 pines).

•

Leds de colores, rojo y verde principalmente (en algunos, también amarrillo).

•

Condensadores electrolíticos, principalmente de 100 uF.

•

Resistencias de valores: 330 Ω, 1 kΩ y 10 kΩ.

•

Fotorresistencia.

•

Diodo rectificadores, principalmente 1n4007 o similares.

•

Pulsadores.

•

Cable de conexión USB.

Otros componentes que se pueden incluir en algunos kits, que a su vez aumentarán las posibilidades de los montajes a realizar son: •

Más componentes resistivos y de varios valores: resistencias, condensadores y resistencias variables.

•

Mini Servo.

•

Zumbador.

•

Sensor de inclinación.

•

Termistor.

11

1. ¿Qué es Arduino? •

Fotorresistencia.

•

Interruptores.

•

Sensor de temperatura.

•

Transistores, principalmente 2N2222 o similar.

Además en algunos casos también incluyen algún tipo de documentación: montajes tipo, CD-ROM, hoja con los valores de resistencias, caja para guardar el material, etc. Aquí el usuario decide qué va a hacer, incluso puede ir a la tienda de electrónica e ir comprando conforme vayan aumentando sus necesidades. En este punto podemos incluir un par de kits interesantes: el primero consiste en realizar un diseño modular denominado Grove (figura 1.4) y el segundo ofrece facilidades de montaje denominado SparkFun Inventor’s (figura 1.5).

Figura 1.4. Kit de iniciación Grove (Cortesía seeed studio).

Figura 1.5. Kit Inventor’s (Cortesía de SparkFun).

12

Iniciación a Arduino UNO El primero simplifica mucho las conexiones por lo que permite realizar pruebas sin necesidad de tener conocimientos de electrónica. Por el contrario, el segundo ofrece más posibilidades de interacción y ampliación, aunque el primero dispone de una gran cantidad de módulos adicionales con multitud de sensores y elementos de control. Por el contrario, al estar disponible en placas de circuito impreso montadas y la realización de las conexiones mediante conectores específicos, se traduce en que el precio será mayor. Por otro lado, debemos tener en cuenta que los componentes que se han comentados son los básicos para iniciarse a trabajar con Arduino, pero se puede encontrar una gran cantidad de elementos adicionales que aportarán al montaje o diseño mayores posibilidades. Destacamos los siguientes: barra de leds, conexión bluetooth, receptor de infrarrojos, receptores de radiofrecuencia, etc. Pero como el objetivo de este texto es a modo de iniciación y como base, entonces con los componentes que puede encontrar en los kits de iniciación será suficiente para realizar todos los montajes propuestos en el libro. Después, cuando se adentre más en este campo, verá que irá necesitando más material o componentes concretos para una u otra utilización, como por ejemplo: integración con Android, pequeños montajes de robótica, controles de sistemas de riego agrícola, domótica, etc. El Arduino necesita una alimentación que sirva para que empiece a trabajar, no hay que olvidar que se trata de un circuito electrónico formado principalmente por un microcontrolador, también dispone de conexiones para alimentar a los propios periféricos o sensores que se conecten y ello añadirá limitaciones. En los actuales Arduino UNO, al conectar el cable USB, este suministra energía para que funcione, además de poder establecer la comunicación con el ordenador, por lo que no será necesaria una fuente de alimentación externa. Requerirá de una fuente de alimentación externa cuando se utilicen placas adicionales (debido a un aumento del consumo) o si Arduino tiene una conexión en serie en vez de USB. Existe una limitación de corriente de 500 miliamperios para el puerto USB, aunque para que no se sobrepase este valor se dispone en la propia placa de elementos de protección con posterior rearme. En consecuencia, para pequeños montajes no será necesario conectar la fuente de alimentación externa. Pero si el montaje es considerable o si se desea que el sistema sea autónomo sin conexión al ordenador, sí que se necesitará.

13

1. ¿Qué es Arduino? La forma de conectar una fuente de alimentación externa es a través de los pines: Vin y GND, o a través del conector jack (figura 1.6). La condición a destacar es que los rangos de trabajo de la fuente externa son de 6 a 25V, teniendo en cuenta la polaridad correcta del conector (positivo el interior y negativo el exterior). También se puede utilizar la alimentación a través de pilas alcalinas como el caso del kit de inicialización de Grove, para conectar a Vin, o incluir un portapilas con conector jack. Del mismo modo se puede disponer de una fuente de alimentación de laboratorio con opciones adicionales muy interesantes, por ejemplo: pantalla de visualización de tensión y corriente, limitadores de corriente, variación de la tensión de salida, circuitos de protección contra sobretensiones y sobrecorrientes. Esta última opción, aunque es la mejor, es la más cara, y después si se desea llevar el circuito para integrarlo es algo engorroso, por lo que esa fuente de alimentación podría ser sustituida por: fuentes de alimentación portátiles, diseñar la propia fuente de alimentación, reutilizar viejos cargadores de baterías de móviles (siempre que se ajusten a los requisitos de tensiones y corrientes comentados) o a reutilizar una fuente de alimentación de un ordenador en desuso.

Figura 1.6. Conector jack de alimentación exterior Arduino UNO.

Nota: no olvidar conectar el terminal de GND o negativo cuando se utilice una fuente de alimentación externa. El procedimiento es sencillo si se decide reutilizar una fuente de alimentación de ordenador. Para ello hay que utilizar los cables ya disponibles y eliminar el resto de cables, es decir, los que no se necesiten. En la figura 1.7 se muestra un esquema de conexionado para la fuente de alimentación a partir de una fuente ATX 14

Iniciación a Arduino UNO manteniendo el código de colores que se suele utilizar. Además se muestra la forma de conexión de los leds, de tal forma que el led verde se encenderá cuando la fuente de alimentación esté en funcionamiento (aprovechando la alimentación de +5V) y el led amarrillo para indicar que la fuente de alimentación está conectada al suministro eléctrico (aprovecha la alimentación de reserva denominada +5VDC Standby Voltage). La puesta en marcha se realiza con el interruptor que conmuta entre Ps-On a masa para poner en funcionamiento la fuente de alimentación o lo deja en circuito abierto para que permanezca apagada. Para los menos atrevidos se muestra en la figura 1.7 un kit que permite conectar directamente el conector de salida de la fuente de alimentación sin tener que desmontar o quitar cables de la propia fuente de alimentación.

Figura 1.7. Esquema conexionado reutilización fuente ordenador.

1.6 Programar: ¿qué necesito saber? Como se ha comentado anteriormente, se utiliza un lenguaje de programación basado en Java o C++, y similar al lenguaje C. Por ello, los usuarios que tengan nociones sobre estos lenguajes les resultará muy fácil su programación. Los que no

15

1. ¿Qué es Arduino? tengan conocimientos sobre estos lenguajes no tendrán grandes dificultades, porque se trata de un lenguaje de alto nivel. Llegados a este punto conviene conocer ciertas definiciones que se irán utilizando en los próximos capítulos: • Constantes: son datos cuyo valor no cambia durante la ejecución del programa. • Variables: son datos que tomarán cierto valor, que luego podrá ser modificado o no durante la ejecución del programa. Se identifican por un nombre definido por el usuario. En Arduino, al definir la variable, se le asigna un valor y un tipo. El tipo definido determinará los valores que puede tomar. Los tipos disponibles son: - int (integer): almacena un número en 2 bytes (corresponde a 16 bits). Cuando no es necesario valores con decimales, puede tomar valores desde -32.768 hasta 32.767. - long: cuando no es suficiente con un int se recurre a un long. Almacena un número en 4 bytes (corresponde a 32 bits), y puede tomar valores desde -2.147.483.648 hasta 2.147.483.647. No almacena valores decimales, solo enteros. - boolean: solo puede almacenar dos valores true (verdad) o false (falso). Solo utiliza 1 bit para almacenar el valor. - float: cuando se requiere operaciones con decimales, almacena un número en 4 bytes (32 bits) y puede tomar valores desde 3.4028235·1038 hasta 3.4028235·1038. - char: almacena un carácter utilizado en código ASCII. Por ejemplo, la letra A se almacena con el valor 65. Para almacenar valores se utiliza 1 byte (8 bits). La forma de definirlo en Arduino es como se muestra a continuación: int variable=12; // tipo nombre=valor Nota: como se habrá dado cuenta, para asignar un resultado de una operación matemática o valor a una variable, se utiliza el símbolo =. No se debe confundir con la condición de comparación que es = =.

16

Iniciación a Arduino UNO • Operadores: es un símbolo que indica una cierta operación sobre uno o varios objetos del lenguaje. Pueden ser: operadores lógicos y operadores matemáticos. Los operadores lógicos sirven para establecer comparaciones o condiciones, de tal forma que si se cumple devuelve true y si no se cumple devuelve false. Se utiliza en la condiciones de las estructuras de control y son: igual (= =), distinto (!=), menor que (), menor o igual (< =) y mayor igual (> =). Cuando se tiene que cumplir más de una condición se utilizan los operadores booleanos, los cuales son: and (&&) y or (||). El primero, para cuando quiera que se cumplan ambas condiciones. Y el segundo, para cuando se cumpla una de las dos condiciones. Los operadores matemáticos se utilizan para manipular valores, y son: suma (+), resta (-), multiplicación (*) y división (/). • Palabras reservadas o clave: son un grupo de palabras con una finalidad determinada. • Comentarios: sirve para introducir aclaraciones del código escrito. Si se utilizan en la misma línea se puede utilizar //. Si el inicio y el final del comentario se encuentran en distintas líneas entonces se utiliza /* xxxx*/ (donde xxx corresponde al propio comentario). • Funciones: se trata de un código ya escrito que puede ser utilizado varias veces escribiendo solo el nombre de la función. Por ejemplo, en Arduino existe una función que al escribirla leerá el estado de una entrada digital, cuya función es digitalRead(). Entre paréntesis se incluye la configuración de la función, es decir, si necesita un dato de partida (variable/s de entrada/s) y/o da un resultado (variable/s de salida/s). En el libro se irán viendo las funciones conforme sea necesario para la realización de cada montaje y su respectivo código de programación. • Librerías: son un conjunto de funciones agrupadas en un fichero. Se escriben al inicio del programa (precedidas de una almohadilla, #) y si no se incluyen, entonces no se podrán utilizar las funciones que contengan. Tienen la extensión *.h. Por ejemplo, cuando se vaya a utilizar la pantalla serie LCD se requerirá disponer de la librería serialLCD.h, la cual sirve para utilizar la función slcd.print(), y si no se ha incluido dará un error en la compilación.

17

1. ¿Qué es Arduino? Del mismo modo conviene conocer ciertas estructuras de programación, tales como: • Estructuras de control selectivas: denominadas condicionales, porque se utilizan para la toma de decisiones en función de la evolución del valor las variables. Las palabras clave para este tipo de estructuras son: if, else y switch. • Estructuras de control iterativas: denominadas bucles, porque permiten la ejecución repetitiva de sentencias durante un número determinado de veces, controlado y definido por un algoritmo. Las palabras clave para este tipo de estructuras son: while, for y do while. A continuación se muestran las estructuras comentadas. La primera corresponde a if y else. Para una mejor comprensión se puede utilizar su traducción, es decir, si se cumple lo que hay entre paréntesis entonces se ejecuta lo que hay entre corchetes a continuación del if. Si no se cumple, se ejecuta lo que hay entre corchetes, a continuación del else. La estructura es la que se muestra a continuación: if ( condición ){ //Bloque que se ejecuta si se cumple la condición }

// Fin if

else{ //Bloque que se ejecuta si no se cumple la condición }

// Fin else

La segunda corresponde a switch, cuya traducción es ‘cambiar’, es decir, en función del valor de la variable entre paréntesis cambia de una opción a otra ejecutándose el código que hay a continuación; y si no cumple ninguna de las opciones indicadas, se ejecutará en código indicado a continuación de la opción por defecto, default. La palabra break indica que la ejecución salta afuera de los corchetes. La estructura es la que se muestra a continuación: switch ( variable ){ case opción 1: //Si variable == 1* ejecutar siguiente código break;

18

Iniciación a Arduino UNO case opción 2: //Si variable == 2* ejecutar siguiente código break; default:

// Sino es uno de los casos anteriores

break; // Salta fuera de la función }

// Fin switch

La tercera corresponde a while, cuya traducción es ‘mientras’, es decir, mientras se vaya cumpliendo la condición entre paréntesis se estará ejecutando continuamente el código incluido entre corchetes. La estructura es la que se muestra a continuación: while ( condición ){ //Bloque de instrucciones a ejecutar }

//fin while

La cuarta y última que se muestra es for, y se utilizar para ejecutar cierto código una cantidad de veces determinada, por ello entre paréntesis hay tres condiciones separadas por punto y coma. El primer término sirve para indicar la condición inicial, a continuación se ejecutará el código entre corchetas hasta que se cumpla la condición del segundo término, y cada vez que se ejecute el código entre corchetes se ejecutará lo indicado en el tercer término. Por ejemplo si se desea que algo se repita 10 veces, se utilizará una variable cuyo valor inicial será asignarle el valor 0, la condición para que se siga ejecutando el valor es que sea menor o igual a 10, y cada vez que se ejecute el valor de la variable se incrementará en 1. La estructura es la que se muestra a continuación: for( dar valores iniciales ; condiciones ; incrementos ){ // Conjunto de instrucciones a ejecutar en el bucle }

//fin for

Comentar, llegado a este punto, que el código que se escribe se podría decir que es secuencial; es decir, empieza por lo escrito por la línea 1 hasta la última línea escrita. Aunque puede haber saltos condicionales utilizando las estructuras comentadas en los párrafos anteriores. También se podrá encontrar con que dentro de una estructura hay otra estructura distinta. Por ejemplo, dentro de un while encontrarme con un for; o

19

1. ¿Qué es Arduino? encadenar estructuras, por ejemplo, dentro de una condición if encontrarse con otro if. Como ya verá más adelante, a mayor dificultad de la aplicación, más condiciones tendrá que cumplir y, en consecuencia, más líneas tendrá de código. Como consecuencia, el tamaño del fichero será mayor. Pero por ahora no se preocupe, ya veremos más adelante algunos y comenzará a practicar. Llegados a este punto, una recomendación, que se irá repitiendo a lo largo del texto, es la de incluir todos los comentarios que crea pertinentes porque lo escrito ya no se olvida.

1.7 Actividades propuestas 1.

Realice una búsqueda por Internet para ver si realmente es interesante la compra en formato de kit de todo el material para iniciarse en el mundo de Arduino.

2.

Indique si las siguientes afirmaciones son verdaderas o falsas. En caso de ser erróneas, corríjalas. a) La sentencia for se utiliza para ejecutar unas líneas de código una cantidad de veces. b) La sentencia switch se utiliza para ejecutar un código mientras se cumpla una determinada condición. c) La palabra break se utiliza con la sentencia while. d) Las sentencias iterativas o bucles son: if, else y switch. e) Las sentencias selectivas o condicionales son: if, else y switch.

3.

Teniendo en cuenta el siguiente ejemplo de la sentencia for para que se repita 10 veces, realice los cambios para que la sentencia se repita 5 veces. Nota: se ha utilizado la variable cuenta. for( cuenta=0 ; cuenta0){ caracter=Serial.read();} // Según el carácter se modifica el valor de la variable retardo if(caracter=='r'){ retardo==500;

// 0,5s encendido y 0,5s apagado

Serial.println("rapido");} if(caracter=='l'){ retardo==2000;

// 2s encendido y 2s apagado

Serial.println("lento");} if(caracter=='d'){ retardo==1000;

// 1s encendido y 1s apagado

Serial.println("defecto");} digitalWrite(led, HIGH);

// Activa la salida 13

delay(retardo);

// Retando de 1000ms=1s

digitalWrite(led, LOW);

// Desactiva la salida 13

delay(retardo);

// Retardo de 100ms=1s

Serial,println(retardo);

// Envía valor de variable retardo

}

// Fin loop

37

2. Primeros pasos Nota: no se necesita realizar ninguna conexión adicional a la placa. En la figura 2.16, se muestra la ventana del monitor para el ejemplo de código mostrado en las líneas anteriores. Además verá como el led de la placa de Ardunio, al modificar el retardo de tiempo entre encendido y apagado, este se encenderá y apagará más rápido o más lento.

Figura 2.16. Ventana monitor del ejemplo.

2.6 Actividades propuestas 1. Realizar un sketch utilizando el monitor de tal forma que cuando se envíe el carácter e, el led conectado al pin 13 se encienda y muestre el texto encendido. Por el contrario, si se envía el carácter a, que el led conectado al pin 13 se apague y muestre el texto apagado. Conecte Arduino al ordenador y verifique el funcionamiento del código escrito. 2. Realizar un sketch que provoque que el led conectado al pin 13 parpadee, y envíe un 1 al ordenador cuando esté encendido y un 0 cuando esté apagado. Conecte Arduino al ordenador y verifique el funcionamiento del código escrito.

38

3. Entradas y salidas digitales 3.1 Introducción En este tercer capítulo se verán las nociones de programación para operar con los pines de entrada y salida digital. Además, se mostrarán las nociones básicas a tener en cuenta sobre fundamentos de electrónica necesarios para la realización de los montajes propuestos. En el próximo capítulo se mostrarán nuevas funciones de las conexiones digitales.

3.2 Pines de entrada y salida digitales en Arduino En la placa de Arduino UNO aparecen, en un lateral, las conexiones denominadas DIGITAL (figura 3.1), cuyo valor puede tomar dos valores de tensión, que se corresponden con activado y desactivado. Estos dos valores se identifican en el software como TRUE para activado y FALSE para desactivado. En la realidad se corresponden con dos valores distintos de tensión, cuyos valores típicos son 0 voltios para desactivado y 5 voltios para activado.

Figura 3.1. Conexiones pines digitales.

Estas conexiones se pueden configurar como entrada o salida. Por tanto, se deben configurar primero y se utilizarán después. Por defecto se encuentran definidas como entrada, aunque para seguir los mismos pasos lógicos, en todos los 39

3. Entradas y salidas digitales diseños propuestos (código) que se muestran en el libro se definen tanto si son entradas o salidas. El código para definirlo se incluirá en la función setup(), tal y como se muestra a continuación: pinMode (número del pin, modo); pinMode (13, INPUT);

// Pin 13 configurado como entrada

pinMode (13, OUTPUT);

// Pin 13 configurado como salida

Una vez configurado el pin como entrada o salida, se procede a utilizarlo. En el caso de que sea definido como salida mediante software se podrá activar o desactivar ese pin. Para ello se utiliza el siguiente código: digitalWrite (número del pin, valor); digitalWrite (13, HIGH);

// Activar pin 13

digitalWrite (13,LOW);

// Desactivar pin 13

Si se configura como entrada, se podrá leer en su estado. Para ello se puede definir una variable de tipo int, cuyo valor es HIGH si tiene presencia de tensión (entrada activa) o LOW si no tiene presencia de tensión (entrada desactivada). También se puede utilizar la propia función en una condición en estructuras de control. El código utilizado es el que se muestra a continuación: int digitalRead(número del pin); int entrada=0;

// Definir variable

entrada=digitalRead (13);

// Leer estado del pin 13

Al configurar un pin digital como salida, en realidad se está configurando como de alta impedancia (entrada) o de baja impedancia (salida), de tal forma que al configurarlo como alta impedancia no es capaz de entregar corriente y cuando está configurado a baja impedancia es capaz de entregar valores elevados de corriente. Aunque Arduino presenta limitaciones en la corriente entregada, con un valor máximo de 200 mA, sin embargo, es recomendable no sobrepasar los 20 mA para proteger la placa, ya que de lo contrario se puede deteriorar esa conexión o el propio microcontrolador. En consecuencia, no es recomendable conectar salidas directamente a los actuadores a excepción de si solo se conecta un diodo led. Para ello se utilizan otros elementos auxiliares como: transistores, relés, optoacopladores o transistores MOSFET.

40

Iniciación a Arduino UNO

3.3 Montajes I: fundamentos de electrónica Llegados a este punto y antes de comenzar a realizar los montajes con componentes electrónicos, se incluye este apartado con una breve descripción sobre nociones básicas a tener en cuenta sobre electrónica. •

Fuerza electromotriz: se corresponde con la fuerza necesaria para desplazar los electrones desde el polo negativo al positivo, creándose una diferencia de potencial. A dicha diferencia de potencial se le denomina fuerza electromotriz. En la figura 3.2.a, se puede ver el ejemplo real de un circuito, en donde se ha conectado una pila a una carga lumínica, así como el desplazamiento de los electrones necesario para crear la diferencia de potencial. Se simboliza como f.e.m. y sus unidades son voltios (V).

•

Intensidad de corriente eléctrica: la intensidad de corriente eléctrica es la cantidad de carga (q en culombios) que atraviesa una sección del conductor (S) por unidad de tiempo (t en segundos) (figura 3.1.b). Se simboliza por una I y las unidades que lo definen son los amperios (A). Hay que tener en cuenta que el sentido de la corriente eléctrica es contrario al flujo de electrones (figura 3.2.c).

Figura 3.2. Complementos definiciones.

•

Resistencia eléctrica: se define la resistencia como la oposición que presenta el conductor al paso de la corriente, es decir, la dificultad que encuentran los electrones para circular entre los átomos del conductor. Se simboliza con una R, y sus unidades son lo ohmios que se simbolizan con Ω. Su valor será dependiente del: material (resistividad, ρ, unidades Ω·m), longitud (l, unidades m) y la sección (S, unidades m2), siguiendo la siguiente ecuación:

R = ρ·

l S

[Ω]

41

3. Entradas y salidas digitales •

Potencia eléctrica: es el trabajo eléctrico (W, unidades en julios, J) realizado por unidad de tiempo. Se simboliza con una P, y sus unidades son vatios y se simbolizan como W, siguiendo la siguiente ecuación:

P=

W t

[W ]

Vistas las definiciones básicas sobre electrónica, hay que comentar la ley de Ohm, que define la relación entre la tensión aplicada entre dos puntos de un conductor (V) y la intensidad de corriente (I) que circula. Dicha relación es constante y se corresponde con la resistencia eléctrica, tal y como se indica en la siguiente ecuación:

V = R·I

[V ]

Del mismo modo se establece para cargar resistivas que la potencia consumida (P) por la misma es igual al producto de la caída de tensión (V) por la corriente que lo atraviesa (I). Se indica en la siguiente ecuación:

P = V ·I

[W ]

En la figura 3.3, se muestra el circuito más simple que representa la ley de ohm, así como el círculo de equivalencias que sirve de guía para establecer relaciones entre los términos de las ecuaciones mostradas anteriormente.

Figura 3.4. Ley de Ohm.

3.4 Montajes II: protoboard o placa de prototipos Una de las ventajas que ofrece Arduino es la facilidad de conexionado mediante unos simples cables. Sin embargo, para añadir y realizar pruebas se requiere de otro

42

Iniciación a Arduino UNO elemento que facilita el montaje y las conexiones entre los componentes. Este dispositivo es la protoboard o placa de prototipos (figura 3.5). En el mercado existen de varios tamaños y pueden incluir conexiones adicionales para facilitar la conexión de una fuente de alimentación exterior, lo que va asociado a un aumento del coste. Tanto la que se ha mostrado en la figura 3.5 como la que se distribuye en los principales kits de Arduino es la de 400 pines, y con esta es suficiente para la realización de los montajes que se van a realizar. De todos modos, si continúa en su andadura por el mundo de Arduino puede necesitar unas placas de prototipo con mayor número de conexiones.

Figura 3.5. Protoboard o placa de prototipos (Cortesía de www.electan.com).

Figura 3.6. Kit de conexiones (Cortesía de Molgar).

Para facilitar las conexiones se puede disponer de un rollo de hilo, aunque para los iniciados es interesante disponer de un kit con trozos de hilo ya cortados, lo cual facilita en gran medida la realización de los montajes (figura 3.6). Algunos kits ya ofrecen un conjunto con aislamientos de diferentes colores, lo cual es mejor

43

3. Entradas y salidas digitales para no equivocarse al realizar las conexiones o en la revisión ante fallos o modificaciones. Una placa de prototipos no es más que una placa con múltiples orificios, que se encuentran distribuidos de forma que los que se hallan en la misma fila están interconectados mediante unas chapas metálicas. Además, para facilitar la conexión al introducir el terminal del componente, este ejerce suficiente presión para separarlas pero estas a su vez ejercen la suficiente presión para sujetar el componente y asegurar la conexión eléctrica. Se muestra en la figura 3.7.

Figura 3.7. Interior placa de prototipos (Cortesía Spankfun).

Las conexiones en dos columnas situadas en los laterales se utilizan para la alimentación de los circuitos, normalmente una para el valor de tensión positivo y otro para el negativo (GND o de referencia). En la parte central se dispone de dos columnas diferenciadas de 5 pines cada una. Estas se encuentran conectadas entre cada fila, pero cada columna separada por una hendidura. Por ejemplo, en la figura 3.8, desde a hasta e están conectadas entre sí, y desde f hasta j están conectadas entre sí, pero entre ellas no hay conexión. Puede verlo de forma más clara en la figura 3.8, donde se detallan las conexiones.

44

Iniciación a Arduino UNO

Figura 3.8. Conexionado placa de prototipos.

3.5 Conexionado de leds como salida En el capítulo interior ya se encendía un led, pero este está incorporado en la placa, además de que solo hay uno, y se pueden utilizar más salidas para encender varios. Pero ¿cómo se conectan? En este punto si no se desea saber cómo funciona o se conecta, puede recurrir a los kits modulares que permiten conectar una salida digital de Arduino a otra placa con unos cables ya disponibles, sin posibilidad de realizar un conexionado erróneo (Grove). Pero si no disponemos de dicho kit o queremos conectar varios leds, entonces tendríamos que comprar varios módulos y el coste sería mayor. Por tanto, vamos a tener en cuenta una serie de observaciones. El diodo led es un dispositivo semiconductor que se utiliza como indicador, en este caso para saber que se ha activado una salida. Su funcionamiento se basa en que al aplicar una diferencia de potencial este provoca una corriente, que al atravesar el diodo y alcanzar cierta caída de tensión, este se enciende. El símbolo utilizado es el que se muestra en la figura 3.9 junto a una resistencia, la cual provoca una oposición al paso de corriente y a su vez una caída de tensión en sus extremos. La utilidad de la resistencia es que al poder ajustar su valor estoy ajustando su caída de tensión (puesto que cuando un led tiene una caída de tensión fija) estoy limitando la corriente que circulará por el led y a su vez sirve de protección y regulación de la luminosidad.

45

3. Entradas y salidas digitales

Figura 3.9. Circuito polarización del diodo.

Llegados a este punto hay que tener en cuenta que el diodo led tiene polaridad, de tal forma que si se conecta al revés este no se encenderá. Para indicar cuál es terminal de ánodo (A) y cátodo (K), hay que saber que la corriente tiene que circular del ánodo al cátodo. Para identificar los terminales hay que tener en cuenta que: •

El ánodo será el más largo de las dos conexiones.

•

El cátodo será la conexión que se encuentra al lado que presenta un corte.

Figura 3.10. Identificación terminales diodo led.

Otro aspecto a tener en cuenta es que se ha indicado la utilización de una resistencia, pero si observa las que tenga disponibles (en el kit por ejemplo) verá que todas son iguales (incluso del mismo tamaño), y se diferencian por unas rayas de colores. Entonces, ¿cuál escoger?

46

Iniciación a Arduino UNO Las resistencias disponibles comercialmente no abarcan todos los valores, sino que siguen unos estándares. El más utilizado es el denominado como E24 y se suelen denominar como valores normalizados. Ahora bien, para identificar de qué valor es una resistencia hay que leer esas rayas de colores que se han comentado; es decir, hay un código de colores, tal y como se muestra en la tabla 3.1, que sigue el orden que se muestra en la figura 3.11.

Figura 3.11. Identificación valores de resistencias. Color de la banda

1.ª cifra

2.ª cifra

Multiplicador

Tolerancia

Negro

0

0

1

-

Marrón

1

1

10

± 1%

Rojo

2

2

100

± 2%

Naranja

3

3

1 000

-

Amarillo

4

4

10 000

± 4%

Verde

5

5

100 000

± 0,5%

Azul

6

6

1 000 000

± 0,25%

Morado

7

7

10000000

± 0,1%

Gris

8

8

100000000

± 0,05%

Blanco

9

9

1000000000

-

Dorado

-

-

0,1

± 5%

Plateado

-

-

0,01

± 10%

Tabla 3.1. Código de colores de resistencias.

47

3. Entradas y salidas digitales El valor típico de la resistencia utilizado para los diodos led suele ser de 330 Ω. También es común encontrar valores de 220 Ω, para una tensión de alimentación de 5 voltios.

Ejercicio resuelto 2: semáforo El siguiente montaje o diseño se basa en el funcionamiento de un ascensor. Para ello se utilizan los pines 13 a 11, y seguiremos la siguiente secuencia: 1. Se enciende el led rojo conectado al pin 13. 2. Pasados 5 segundos el led rojo se apaga y se enciende el led amarrillo conectado al pin 12. 3. Pasados otros 5 segundos el led amarillo se apaga y se enciende el led verde conectado al pin 11. 4. Pasados otros 5 segundos el led verde se apaga y se enciende el led rojo. Repetiremos la secuencia.

Figura 3.12. Circuito semáforo con Arduino.

El esquema de montaje se muestra en la figura 3.12, donde se utilizan resistencias de 330 Ω con el código de colores siguiente: Amarrillo-Amarillo-Marrón El código del sketch a introducir es el que se muestra a continuación. Puede intentar realizarlo antes de ver la solución.

48

Iniciación a Arduino UNO /* Capítulo 3 libro curso de introducción Arduino. Semáforo: 5s Rojo->5s Amarillo->5s Verde->5s Amarillo->repetir */ int rojo=13;

// Asignación variables a pines

int amarillo=12; int verde=11; void setup() { // Configuración de los pines 11 al 13 como salidas pinMode(rojo,OUTPUT); pinMode(amarillo,OUTPUT); pinMode(verde,OUTPUT); }

// Fin setup

void loop() { digitalWrite(rojo,HIGH); // Enciende rojo delay(5000);

// Retardo 5 segundos

digitalWrite(rojo,LOW);

// Apaga rojo

digitalWrite(amarillo,HIGH);

// Enciende amarillo

delay(5000);

// Retardo 5 segundos

digitalWrite(amarillo,LOW);

// Apaga amarillo

digitalWrite(verde,HIGH);

// Enciende verde

delay(5000);

// Retardo 5 segundos

digitalWrite(verde,LOW);

// Apaga rojo

digitalWrite(amarillo,HIGH);

// Enciende amarillo

delay(5000);

// Retardo 5 segundos

digitalWrite(amarillo,LOW);

// Enciende amarillo

}

// Fin loop

49

3. Entradas y salidas digitales

3.6 Conexionado de pulsadores como entrada Para conectar pulsadores a las entradas digitales de Arduino, se utiliza la conexión mediante resistencias pull-down (figura 3.13), de tal forma que siempre haya un estado lógico a la entrada del microcontrolador; es decir, 5 o 0 voltios. De tal forma que si no se pulsa se conecta la entrada a gnd (0 voltios) a través de la resistencia, y cuando se pulsa a través del pulsador se conecta la entrada a 5 voltios. Cambiando la resistencia por el pulsador y viceversa, el funcionamiento es a la inversa; es decir, cuando se pulsa se conecta a través del pulsador la entrada a gnd (0 voltios) y cuando no se pulsa la entrada está a 5 voltios a través de la resistencia. Esta configuración recibe el nombre de resistencia pull-up (figura 3.14).

Figura 3.13. Pulsador pull-down.

Figura 3.14. Pulsador pull-up.

50

Iniciación a Arduino UNO Nota: para la resistencia con los pulsadores, tanto pull-up o pull-down, tiene valores típicos de 10 o 22 kΩ. Se puede implementar la resistencia pull-up mediante el propio hardware del microcontrolador, utilizando el siguiente código en el setup(): void setup (){ pinMode (número del pin,INPUT);

// Configura pin como salida

digitalWrite (número del pin, HIGH);

// Activar R de pull-up

}

//Fin setup

Mirando los pulsadores que hay en los kit y los utilizados para los montajes en placas de circuito impreso (usados en electrónica), tienen 4 pines, y los símbolos mostrados en las figuras 3.13 y 3.14, solo hay dos conexiones. Entonces, ¿cómo se conecta? Para los familiarizados con la electrónica puede ser una tarea obvia o recurrir a utilizar un instrumento de medida para realizar comprobaciones, pero en realidad no hace falta conociendo un poco más al componente en cuestión. Por ello se muestra en la figura 3.15 las medidas y circuito interno de un pulsador. Ahora observando el circuito interno (figura 3.15 parte inferior derecha) se puede entender que dos terminales están interconectadas (la 4 con el 3 y el 2 con el 1) y entre medio se encuentra la conexión que se cierra al pulsarlo; es decir, cuando se pulsa los cuatro pines se encuentran interconectados.

Figura 3.15. Pulsadores.

51

3. Entradas y salidas digitales Ahora bien, también se puede realizar un simple montaje que me va a permitir comprobar el funcionamiento, de utilizar una resistencia pull-up o pulldown. Para ello simplemente necesitará: 4 resistencias (2 de 330 Ω y 2 de 10 kΩ), 2 diodos y 2 pulsadores. El montaje se muestra en la figura 3.16, y para la realización del montaje requerirá realizar las conexiones en la placa de prototipos. El código de la resistencia de 10 kΩ es: Marrón-Negro-Amarillo

Figura 3.16. Montaje prueba pulsadores con diodos.

Nota: la alimentación del circuito de la figura 3.16 se ha obtenido de un portapilas con 4 pilas tipo AAA de 1,5 V cada una. Se podría obtener del pin de 5 V de Arduino y el negativo del terminal GND. En este caso deberá estar conectado al ordenador mediante USB para obtener el valor tensión. También se puede recurrir a otras fuentes de tensión externas de 5 voltios.

52

Iniciación a Arduino UNO

Ejercicio resuelto 3: conmutada Conectando dos pulsadores, a los pines 2 y 3, se desea controlar el encendido de 1 led conectado al pin 13. El funcionamiento es similar a una conmutada instalada en una vivienda (control de un punto de luz desde dos puntos); es decir, al pulsar cualquiera de los dos pulsadores, si el led está encendido, se apagará; y si está apagado, se encenderá. Así pues con los dos pulsadores puedo controlar el encendido y apagado del led. El esquema de montaje se muestra en la figura 3.17, donde se utilizan resistencias pull-up de 10 kΩ.

Figura 3.17. Circuito conmutado con Arduino.

El código del sketch a introducir es el que se muestra a continuación. Puede intentar realizarlo antes de ver la solución. /* Capítulo 3 libro curso de introducción Arduino. Conmutada: Con dos pulsadores en pines 1 y 2 controlamos un led en el pin 13*/ int rojo=13;

// Asignación variables a pines

int pulsador1=2; int pulsador2=3; boolean encendido=0;

// Variable led encendido o apagado

53

3. Entradas y salidas digitales void setup() { // Configuración de los pines 1 y 2 como entrada y 13 como salida pinMode(rojo,OUTPUT); pinMode(pulsador1,INPUT); pinMode(pulsador2,INPUT); }

// Fin setup

void loop() { //Detecta si se ha pulsado if(digitalRead(pulsador1)==LOW ||digitalRead(pulsador2)==LOW){ if(encendido==0){

// Si está apagado el led se enciende

encendido=1; digitalWrite(rojo,HIGH);} else{

// Si está encendido el led se apaga

encendido=0; digitalWrite(rojo,LOW);} /* La siguiente línea es un bucle cerrado estará en él hasta que se suelte el pulsador */ while(digitalRead(pulsador1)==LOW||digitalRead(pulsador2)==LOW){} }

// Fin if

}

// Fin loop

Comentar que aunque se han incluido comentarios en el propio texto, se van a comentar algunos puntos:

54

•

En la comparación se han incluido dos condiciones que se han unido por operando lógico OR (||) cuyos símbolos se encuentran mediante la siguiente combinación de teclas Alt Gr+1, y cuyo significado es que para que se cumpla dicha condición se debe cumplir una u otra condición. El operando lógico para indicar que se cumplan dos condiciones es AND (&&).

•

Si no se incluye el while, el código no para de ejecutarse y no se encenderá y apagará como se espera. La solución es que cuando se cumpla que se ha pulsado cualquiera de los dos pulsadores, entradas

Iniciación a Arduino UNO 2 y/o 3 pasen a nivel bajo (0V, LOW) se ejecute el if y a continuación se quede en el bucle while hasta que se deje de pulsar. •

La variable encendido sirve para indicar si el led está encendido o apagado, de tal forma que el primer if detecta si se ha pulsado alguno de los dos pulsadores y el segundo se utiliza para cambiar el valor de la variable encendido; es decir, si vale 0, entonces se activa la salida poniendo la variable encendido a 1. Si no, apaga la salida poniendo la variable encendido a 0.

Ejercicio resuelto 4: semáforo controlado por un pulsador Partiendo del ejercicio resuelto 1 que muestra el ejemplo secuencial de encendido de un semáforo, se quiere controlar el encendido y apagado del sistema, de tal forma que al poner en marcha el Arduino, no se encenderá nada pero con el pulsador conectado al pin 2 se pondrá en marcha el funcionamiento del semáforo (ejercicio resuelto 1). Para que se apague se debe pulsar de nuevo el pulsador. Entonces, independientemente de que el led esté encendido, este se apagará. Si se vuelve a pulsar de nuevo el pulsador, volverá a ponerse en marcha el semáforo empezando por el led rojo. La asignación de pines para la conexión de los diodos es la misma que la del ejercicio resuelto 1. De todas formas, para una mejor aclaración el montaje a realizar se muestra en la figura 3.18.

Figura 3.18. Semáforo controlador con un pulsador.

55

3. Entradas y salidas digitales Comentar que la función delay utilizada pausa el programa. Como consecuencia: no se leen sensores, no se hacen cálculos y no se puede manipular los pines. Es decir, hace que casi toda la actividad se pare. En consecuencia, si se encuentra utilizando la función delay cuando se pulse, entonces no se parará el sistema y no se apagarán los leds. Nota: solo siguen en funcionamiento con la función delay: la comunicación serie de los pines de recepción, los valores de PWM con la función analogWrite, los estados de los pines y las interrupciones. Para evitar eso se utiliza la función millis. Dicha función devuelve los milisegundos transcurridos desde que se arrancó la placa Arduino con el programa actual. Este número se desbordará (volverá a cero) después de aproximadamente 50 días. El valor se debe guardar en una variable tipo long (sin signo), utilizando el siguiente código: unsigned long tiempo=0; tiempo=millis(); En consecuencia se puede utilizar la función millis en sustitución a la función delay. Leyendo el valor de tiempo, se ejecuta un bucle hasta que pase el tiempo prefijado, de tal forma que no se pare el sistema y pueda leer el estado de las entradas. El código utilizado sería el siguiente para un tiempo de 500 milisegundos de retardo para la lectura de las pulsaciones (por ejemplo, para un contador) y utilizando resistencia de pull-up: unsigned long tiempoPrevio=0; tiempoPrevio=millis(); digitalRead(pin) //leer dato // Si han pasado 500 ms de la lectura y el pulsador no está pulsado if (millis()-tiempoPrevio>500 && digitalRead(pin)==HIGH){ // Entonces continúa con el código para incrementar variable }

// fin if

Otro método en el cual se puede utilizar lo indicado anteriormente es mediante while para que realice la misma función que el delay. Pero si mientras está esperando si se pulsa una entrada externa, deje de esperar y continúe ejecutando el

56

Iniciación a Arduino UNO código. Por ejemplo, a continuación se muestra el código que sustituiría a un retardo de 1 segundo (1000 milisegundos) utilizando la función millis: unsigned long tiempoPrevio=0; tiempoPrevio=millis(); while(millis()-tiempoPrevio5s Amarillo->5s Verde->5s Amarillo->repetir con un pulsador conectado al pin 2 se controla la marcha y parada*/ int rojo=13; // Asignación variables a pines int amarillo=12; int verde=11; int pulsador=2; boolean encendido=0;

// Variable led encendido o apagado

unsigned long tiempoPrevio=0;

// Para lectura tiempo con millis()

void setup() { // Configuración de los pines 11 al 13 como salidas pinMode(rojo,OUTPUT); pinMode(amarillo,OUTPUT); pinMode(verde,OUTPUT);

57

3. Entradas y salidas digitales // Configuración del pin 2 como salida pinMode(pulsador,INPUT); }

//fin setup

void loop() { if(digitalRead(pulsador)==LOW){

//Detecta si se ha pulsado

if(encendido==0){

// Si está apagado el led se enciende

encendido=1; digitalWrite(rojo,HIGH);}

// Fin if

else{

// Si está encendido el led se apaga encendido=0;}

// Fin else

/* La siguiente línea es un bucle cerrado y estará en él hasta que suelte el pulsador */ while(digitalRead(pulsador)==LOW){} }

// Fin if

if(encendido==1){ digitalWrite(rojo,HIGH);

// Enciende rojo

tiempoPrevio=millis(); while((millis()-tiempoPrevio)blanco

delay(retardo); }

// Fin loop

Ejercicio resuelto 8: control iluminación tras apertura de puerta Controlar el encendido de una lámpara colocada en un vestíbulo, de tal forma que cuando se abra la puerta de entrada esta permanezca encendida durante 1 minuto. Si la lámpara está encendida y se vuelve a abrir la puerta, el tiempo se debe reiniciar. Por ejemplo, si se deja la puerta abierta la lámpara siempre estará encendida. Para el control de apertura de la puerta se utilizará un interruptor reed colocado en el marco de la misma (figura 4.17).

Figura 4.17.- Detector magnético, interruptor reed (cortesía Security Honeywell).

Figura 4.18. Montaje con relé e interruptor reed para control iluminación.

78

Iniciación a Arduino UNO El esquema del montaje se muestra en la figura 4.18, y el código a implementar es el siguiente: /* Capítulo 4 libro curso de introducción Arduino. Control iluminación: Tras abrir una puerta se mantiene 1 minuto activo un punto de luz*/ int luz=13;

// Asignación variables a pines

int sensorReed=2; int encendido=0;

// Para saber si está encendida

int segundos=0;

// Se incrementa cada segundo

int tiempo=60;

// Duración temporalización en seg.

unsigned long tiempoPrevio=0;

// Variable para utilizar millis

void setup() { // Configuración del pin 13 como salida pinMode(luz,OUTPUT); // Configuración del pin 2 como entrada pinMode(sensorReed,INPUT); Serial.begin(9600);// Configuración comunicación }

// Fin setup

void loop() { // Si detecta que se abre la puerta que se encienda if(digitalRead(sensorReed)==LOW){ digitalWrite(luz,HIGH); encendido=1; delay(200);} // Si se ha encendido se activa el temporizador if(encendido==1){ for(segundos=0;segundos0 for(intensidad=255;intensidad!=0;intensidad=intensidad-15){ analogWrite(led,intensidad); Serial.println(intensidad);

87

5. Salidas digitales PWM delay(retardo);} }

// Fin loop

Para visualizar los cambios en la variable intensidad, la cual ajustará el valor del ciclo de trabajo y la intensidad del led, se utiliza la visualización del monitor por serial0. En la figura 5.3 se puede ver cómo va variando este valor.

Figura 5.3. Monitor variable intensidad.

5.3 Variar la velocidad de un motor de continua Este tipo de control me va a permitir conectar nuevos receptores que a su vez proporcionan más posibilidades a los diseños con Arduino. Una de ellas es conectar a una salida un pequeño motor de continua de 5 voltios de continua. El esquema de montaje a realizar se muestra en la figura 5.4. Con este tipo de motor, además, si se conecta a una salida PWM, se permitirá modificar su velocidad. Se puede apreciar su similitud con el circuito para activar un relé pero sustituyendo las conexiones de la bobina del relé por las conexiones del motor, incluido el diodo conectado en antiparalelo. Si el motor a controlar requiere un mayor consumo o tensiones diferentes a los 5 voltios, se podría recurrir al relé para su puesta en marcha y parada pero no para variar su velocidad. En el caso de querer

88

Iniciación a Arduino UNO variar la velocidad se deber recurrir a otro circuito adicional cuyo funcionamiento es similar al del relé pero que es capaz de trabajar a mayores frecuencias. Por ejemplo, un relé de estado sólido, o montajes con transistores Mosfet. También se puede recurrir a dispositivos (integrados) específicos para el control de motores concretos, como los motores paso a paso, muy útiles en montajes sobre robótica. Debido a que el objetivo de esta obra es a modo introductorio y principios básicos para el manejo de Arduino, si desea ampliar esta información deberá recurrir a una bibliografía más específica.

Figura 5.4. Control motor de 5 voltios dc con Arduino.

Ejercicio resuelto 10: control de velocidad motor dc con dos pulsadores Se desea controlar mediante dos pulsadores la velocidad de un motor dc conectado al pin 6, mediante dos pulsadores conectados a los pines 2 y 3. El pulsador conectado al pin 2 permite aumentar la velocidad del motor progresivamente (aumentando en 15 su valor), mientras que el pulsador conectado al pin 3 permite reducir la velocidad del motor progresivamente (disminuyendo en 15 su valor). Inicialmente el motor estará parado (valor 0 para la variable velocidad), y la velocidad a la cual se haya seleccionado mediante los pulsadores se mantendrá mientras no se pulse ningún pulsador.

89

5. Salidas digitales PWM Cuando se llegue al valor máximo (valor 255 para la variable velocidad), aunque se continúe pulsando para aumentar la velocidad, el valor de la variable no se verá modificado.

Figura 5.5. Montaje control velocidad motor 5 voltios con Arduino.

El esquema del montaje se muestra en la figura 5.5, y el código a implementar es el siguiente: /* Capítulo 5 libro curso de introducción Arduino. Varía velocidad de motor con dos pulsadores */ int motor=5; int pulsadorSubir=2; int pulsadorBajar=3; int velocidad=0; int retardo=200; unsigned long tiempoPrevio=0; void setup() { // Configuración pin como salida pinMode(motor,OUTPUT);

90

// Asignación variable a pin

Iniciación a Arduino UNO // Configura pines 2 y 3 como entradas pinMode(pulsadorSubir,INPUT); pinMode(pulsadorBajar,INPUT); Serial.begin(9600);

// Configuración comunicación

}

// Fin setup

void loop() { // Incrementar valor variable velocidad if(digitalRead(pulsadorSubir)==LOW&&digitalRead(pulsadorBajar)==HIGH){ if(velocidadrCambio){ digitalWrite(pinRele,HIGH); }

// Activa relé de punto de luz // Fin if

else{ digitalWrite(pinRele,LOW);

// Desactiva relé de punto de luz

}

// Fin else

delay(10);

// Pequeño retardo

}

// Fin while

}

// Fin loop

Ejercicio resuelto 19: control de velocidad motor dc con potenciómetro Se desea controlar mediante un potenciómetro, conectado al pin 0 analógico, la velocidad de un motor dc conectado al pin 6. Al aumentar la tensión aumenta la velocidad del motor mediante relación directa. Inicialmente el motor arrancará a la velocidad prefijada por el potenciómetro, y variará conforme se vaya modificando su posición.

Figura 6.13. Montaje variador de velocidad motor dc con potenciómetro.

116

Iniciación a Arduino UNO Como los valores que puede tomar a través de los pines analógicos van de 0 hasta 1023, y el valor de regulación de una salida digital PWM es de 0 hasta 255, y como se busca una relación directa (para 1023 de valor en la entrada analógica le corresponde 255 de valor de ajuste de la señal PWM) se utiliza la siguiente función: map (xx, origen mínimo, origen máximo, destino mínimo, destino máximo); La función map consiste en ajustar un valor (xx) comprendido entre dos rangos (origen) al mismo situado entre dos rangos distintos (destino). La función devuelve el mismo valor pero mapeado; es decir, para el nuevo rango (según valores mínimo y máximo). El esquema del montaje se muestra en la figura 6.13, y el código a implementar es el siguiente: /* Capítulo 6 libro curso de introducción Arduino. Varia velocidad de motor con un potenciómetro */ int potenciometro=0;

//Asignación pin potenciómetro

int motor=6

// Asignación pin salida motor

int velocidad=0;

// Variable velocidad del motor

void setup() { // Configuración pin como salida pinMode(motor,OUTPUT); }

// Fin setup

void loop() { velocidad=analogRead(potenciometro); // Lee valor velocidad=map(velocidad,0,1023,0,255);// mapear valor analogWrite(motor,velocidad);

// Ajustar velocidad

}

// Fin loop

6.5 Actividades propuestas 1.

Para controlar la intensidad lumínica de un diodo led conectado a la entrada digital PWM 3, a partir de un potenciómetro conectado a la entrada 0 analógica, visualice ambos valores en el monitor del serial0.

117

6. Entradas analógicas

118

2.

Se desea que un led conectado a una salida digital parpadee, pero la velocidad de parpadeo se desea controlar a través de un dispositivo externo (potenciómetro). Realice un croquis de conexionado en Arduino seleccionando los pines que considere oportunos.

3.

Realice el programa para Arduino que controle un calefactor, para que se ponga en marcha cuando alcance la temperatura mínima (Tmin) y se pare cuando alcance la temperatura máxima (Tmax). El control de puesta en marcha se realiza a través de un relé conectado al pin digital 1, y el sensor de temperatura a la entrada 0 analógica.

4.

Para iluminar una zona del jardín se desea que se ponga en marcha cuando sea de noche y se apague al amanecer. Como adorno se utiliza un diodo RGB (elige la secuencia de colores que consideres oportuna). Elige los pines a utilizar.

5.

En la entrada de una vivienda se dispone de un punto de luz que normalmente está encendido pero cuando hay suficiente iluminación esta se apaga. Elige los pines a utilizar, así como el material necesario para llevar a cabo el montaje.

6.

Realice el programa para Arduino que active un led conectado al pin digital 12, que se ponga en marcha al accionar un pulsador conectado a la entrada 3, y se apague pasado un tiempo. Dicho tiempo se ajustará mediante un potenciómetro conectado a la entrada analógica 0. Si estando el led encendido se vuelve a pulsar, el tiempo se reinicia. El tiempo máximo es de 3 segundos y el tiempo mínimo es de 0 segundos. Utilice el serial0 para que muestre el tiempo ajustado con el potenciómetro.