ARDUINO -...

ARDUINO

El manual de

ArduinoPaolo Aliverti

Título original de la obra: Il manuale di Arduino Autor: Paolo AlivertiColección: Made for Makers© 2016 Edizioni LSWR

Título de la versión en español de la obra: El manual de Arduino Traducción: Sònia LlenaDiseño de la cubierta: ENEDENÚ ESTUDI DISSENY GRÀFIC

Primera edición, 2016© 2016 MARCOMBO, S.A.

Esta edición de El manual de Arduino ha sido publicada en colaboración con Edizioni LSWR.This edition of Il manuale di Arduino by Paolo Aliverti is published by arrangement with Edizioni LSWR.

«Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra sólo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley.»

ISBN: 978-84-267-2373-4, MARCOMBO, edición en español

ISBN: 978-88-6895-340-9 Edizioni LSWR, edición original

5

Sumario

INTRODUCCIÓN ....................................................................................................... 9

1. EL MUNDO DE ARDUINO ............................................................................13La historia .....................................................................................................................................15Microcontroladores y microprocesadores ...........................................................................17Shield ............................................................................................................................................ 18Maker & Arduino ....................................................................................................................... 19Sitios de referencia.....................................................................................................................21

2. HARDWARE .....................................................................................................23Arduino Uno (o Genuino Uno) ..............................................................................................24¡Con una placa no es suficiente! ............................................................................................27Arduino es Atmel ..................................................................................................................... 40La electrónica no es mi fuerte: shield, TinkerKit y Grove ................................................ 41

3. INSTALACIÓN .................................................................................................47Descarga e instalación ............................................................................................................ 48¡Hola, LED! ..................................................................................................................................52

4. ARDUINO Y EL LENGUAJE C/C++ ............................................................59Aprender a programar ..............................................................................................................61El lenguaje C/C++ .................................................................................................................... 66

5. PROGRAMAR ARDUINO .............................................................................87El sketch .......................................................................................................................................87pinMode ......................................................................................................................................... 91delay ............................................................................................................................................ 94digitalRead.................................................................................................................................101analogWrite................................................................................................................................103Serial Monitor ..........................................................................................................................106analogRead..................................................................................................................................109Controlar el tiempo ...................................................................................................................111Y ahora, ¡un poco de música! ................................................................................................ 113Medir la longitud de una pulsación ..................................................................................... 117

6

El manual de Arduino

Funciones matemáticas ..........................................................................................................118Funciones para caracteres ....................................................................................................120Funciones para manipular bits y bytes ............................................................................... 121Conversiones de tipo .............................................................................................................. 124sizeof ......................................................................................................................................... 125

6. MÁS ALLÁ DE LO BÁSICO ......................................................................... 127Conectar un LED ...................................................................................................................... 127LED ondulante .......................................................................................................................... 129LED ondulante – versión software ....................................................................................... 131LED RGB ..................................................................................................................................... 133Botones ...................................................................................................................................... 134Botón sin resistencia .............................................................................................................. 136Botón en una línea analógica ............................................................................................... 139Utilizar un servomotor ...........................................................................................................140Display ....................................................................................................................................... 143LCD .............................................................................................................................................148Registros de desplazamiento (shift register) ................................................................... 152Módulos ..................................................................................................................................... 156Librerías ..................................................................................................................................... 158

7. PROGRAMACIÓN AVANZADA ............................................................... 163Interrupciones .......................................................................................................................... 163EEPROM y variables persistentes .......................................................................................166Lenguaje ensamblador ...........................................................................................................169Planificadores ............................................................................................................................ 171Contadores................................................................................................................................ 172analogReference........................................................................................................................189El bootloader ............................................................................................................................190Programar los chips AVR ....................................................................................................... 192

8. SENSORES ......................................................................................................201Condensadores variables y potenciómetros ....................................................................201Codificador...............................................................................................................................203Luz ..............................................................................................................................................204Temperatura ............................................................................................................................ 207Humedad ..................................................................................................................................209Gases ...........................................................................................................................................211Sensor de efecto Hall ............................................................................................................. 212Sensor de inclinación ............................................................................................................. 213PIR ............................................................................................................................................... 213Sensores capacitivos ..............................................................................................................214Medidores de distancias por infrarrojos ...........................................................................216Ultrasonidos .............................................................................................................................219Acelerómetro y giroscopio.................................................................................................... 221

7

Sumario

Brújula ....................................................................................................................................... 222GPS............................................................................................................................................. 223Hora y fecha ............................................................................................................................. 224Conectar un micrófono o una fuente de audio ............................................................... 227RFID ........................................................................................................................................... 228Tarjetas de memoria SD .......................................................................................................230Otros sensores ........................................................................................................................ 233

9. ACTUADORES ..............................................................................................235El transistor bipolar ................................................................................................................ 235Controlar un relé ..................................................................................................................... 238Los transistores MOSFET ...................................................................................................... 241Controlar un motor paso a paso ......................................................................................... 246Salidas optoaisladas .............................................................................................................. 247Potenciómetros digitales ...................................................................................................... 248Conectar un DAC ...................................................................................................................250Salida de audio ......................................................................................................................... 251Otros actuadores .................................................................................................................... 252

10. COMUNICARSE ............................................................................................253Un poco de teoría ................................................................................................................... 253Puertos serie ............................................................................................................................ 255Software Serial ........................................................................................................................ 259Convertidores de niveles ......................................................................................................260I2C ............................................................................................................................................... 263SPI .............................................................................................................................................. 267RS232 & Co. ............................................................................................................................. 269Bluetooth .................................................................................................................................. 269ZigBee ........................................................................................................................................274Ethernet .....................................................................................................................................274WiFi ............................................................................................................................................281GSM/GPRS .............................................................................................................................. 282Siguiente paso .........................................................................................................................284

11. ARDUINO YÚN ............................................................................................ 285Arduino más Linux ................................................................................................................. 285Instalación ................................................................................................................................286Programación WiFi ................................................................................................................288OpenWrt-Yun ..........................................................................................................................288Consola ..................................................................................................................................... 295Servidor web sencillo ............................................................................................................296Páginas web dinámicas.........................................................................................................299Reset .......................................................................................................................................... 302Bridge ........................................................................................................................................ 302¿Estáis preparados para empezar?.................................................................................... 307

CONCLUSIÓN .......................................................................................................309

APÉNDICE: LEER EL VALOR DE UNA RESISTENCIA .................................... 311

BIBLIOGRAFÍA RECOMENDADA ..................................................................... 315

GLOSARIO .............................................................................................................. 319

ÍNDICE ANALÍTICO .............................................................................................323

9

Este libro ha permanecido en un cajón durante mucho tiempo, seguramente dema-siado. Nació el día en que empecé a impartir clases sobre Arduino, en 2011, y reco-ge todas las preguntas, dudas y dificultades surgidas cuando intentaba explicar de la manera más sencilla posible temas bastante complejos a un público no técnico. Los asistentes a mis cursos no eran ingenieros, sino diseñadores, inventores, arquitectos, artistas, creativos... Personas que raramente a lo largo de su formación (reglada o no) habían tocado la electrónica. Gracias a sus dudas, sus cuestiones y a su visión del mundo, mucho más abierta que la mía, de ingeniero, aprendí muchas cosas, sobre todo, a mirar desde una perspectiva distinta aquello que ya sabía.Muchas de las ideas y los contenidos han surgido también de los proyectos que he realizado durante estos años, desde 2009, cuando compré mi primer Arduino y quedé sorprendido de la simplicidad de esta solución. Siempre he «trasteado» con la electró-nica y sabía que programar microcontroladores no era una cosa sencilla, debido a los equipos y la experiencia necesarios.Arduino ha cambiado muchas cosas: se puede programar en pocos segundos con un simple cable USB. Además, las instrucciones necesarias son bastante lineales y com-prensibles, tanto que diríamos que parece lenguaje JavaScript en lugar de C. De hecho, muchos makers lo han sacado a modo de «navaja suiza» de su caja de herramientas y lo utilizan en múltiples proyectos, desde los más simples que hacen parpadear luces y LED hasta placas de control para impresoras y drones.El manual de Arduino sería la continuación de mi libro anterior, Elettronica per maker [Electrónica para makers], publicado el año pasado, cuyo objetivo era preparar el te-rreno a los aspirantes a maker. Muchos de mis «alumnos», de hecho, necesitaban entender los conceptos base de la electrónica para poder llegar a Arduino. Así, los dos libros forman una especie de «supermanual» de Arduino, que proporciona al lector todo cuanto necesita para crear un proyecto electrónico.Este manual es un texto intermedio, si bien he intentado mostrarlo todo del modo más simple posible y no dar nada por sabido. A veces, estas simplificaciones podrán

Introducción

10


enervar a los más expertos, pero he tratado de pensar siempre en los lectores «menos técnicos». He querido mantener un enfoque práctico, para situaros en las condiciones de entender y, por tanto, de hacer. En el libro Elettronica per maker cometí algún error, sobre todo en los diseños, todos realizados por mí. De vez en cuando puede colarse algún error debido a la complejidad que supone escribir un libro. También en este libro habrá errores y pido perdón de antemano: si encontráis alguno, no dudéis en indicármelo en mi sitio web, www.zeppelinmaker.it, o por correo electrónico, [email protected]én en este caso he tratado de diseñar las imágenes necesarias. Sin embargo, en alguna ocasión he utilizado Fritzing, pues, además de resultar muy útil para «trazar» prototipos sobre un tablero de circuitos, contiene imágenes vectoriales muy bonitas.

Argumentos del libro y descripción de los capítulosEl Capítulo 1 explica la historia de Arduino, qué es un microcontrolador y para qué sir-ve. En el Capítulo 2 veréis de cerca el hardware de Arduino Uno (o Genuino Uno), con una descripción completa de todas sus partes y una panorámica de todas las placas existentes. El Capítulo 3 es muy práctico y describe la instalación y la primera configu-ración de Arduino. En el Capítulo 4 encontraréis un pequeño curso de programación, dado que muchos aspirantes a maker no son además programadores y es importante, para utilizar Arduino, saber escribir programas. El Capítulo 5 presenta las funciones y los comandos fundamentales de Arduino, que más adelante se tratan con mayor pro-fundidad en el Capítulo 6, deteniéndonos siempre en los aspectos prácticos de su uso.El Capítulo 7 presenta argumentos avanzados: si estáis empezando, os aconsejo que lo leáis solo si es necesario, puesto que trata aspectos que no se utilizan con frecuen-cia y que podrían atemorizaros inútilmente. El Capítulo 8 presenta una amplia panorá-mica de sensores con ejemplos de uso, y el Capítulo 9 habla de actuadores, transisto-res y dispositivos que requieren corrientes «importantes» para funcionar. El Capítulo 10 está dedicado a los mecanismos de comunicación: del puerto serie al GSM. Por último, el Capítulo 11 habla en exclusiva de Arduino Yún.He añadido un Apéndice «electrónico» para explicar cómo leer las resistencias, pues-to que en el libro es un tema que doy por descontado.Es posible acceder a más información, actualizaciones y contenidos extra visitando www.zeppelinmaker.it/manualearduino y arduino.madeformakers.it. El manual de Arduino ha nacido como libro Open Source y en pocos meses ha alcan-zado las 5000 descargas: una cifra significativa. Me gustaría dar las gracias a todos aquellos que han descargado una copia del libro y me han hecho llegar sus observa-

11

Introducción

ciones. Y un agradecimiento en particular para todos aquellos que han contribuido con una donación para dar soporte a mi obra.

El autorMe llamo Paolo Aliverti y soy ingeniero de telecomunicaciones, artesano digital y em-presario.Me gradué en 1999 en el Politécnico de Milán, con una tesis en robótica e inteligencia artificial para realizar un sistema de visión robótica omnidireccional. A los diez años empecé a interesarme por la electrónica y la microinformática. He escrito Il manuale del maker [El manual del maker] (traducido al ingés por Maker Media), Elettronica per maker [Electrónica para makers] y dos libros más sobre la impresión 3D. Escribo regularmente en la revista 3D Printing Creative y, además, organizo cursos y talleres sobre fabricación digital, Internet de las cosas y computación física. Desde 2008 me dedico al diseño y la fabricación de prototipos. En 2015, dejé mi «puesto de trabajo fijo» en el sector ferroviario para dedicarme a mi pasión. En cuanto pueda, me marcho a cualquier montaña con cuerda, pico y grampones.

AdvertenciasLa corriente eléctrica puede ser muy peligrosa: es invisible y, si no se es consciente o no se está seguro de lo que se hace, se pueden sufrir accidentes graves o mortales. No utilicéis nunca para vuestros experimentos la tensión de red a 220 V. Utilizad solo pilas o baterías, sin dejar de prestar, en cualquier caso, la máxima atención.Hace mucho tiempo estaba en Roma para trabajar con los robots de la RoboCup-99. El equipo del Politécnico de Milán tenía un robot llamado Rullit que jugaba en la Middle Size League. Rullit era un robot bastante pesado, alimentado por algunos paquetes de baterías de 12 V de más de un kilo de peso. Tras muchas horas de programación, yo estaba agotado: conectando la alimentación del robot invertí los cables rojos con los negros. ¡Se produjo un fuerte ruido acompañado por una pequeña explosión que perforó el tapete verde del campo de juego!Si no estáis seguros o tenéis dudas, preguntad a un experto, un amigo, un electricista...En Internet, incluso en Facebook, existen muchos sitios y grupos (aunque no se sepa con certeza si una persona es realmente experta).Ni yo ni el editor podemos asumir ninguna responsabilidad por los resultados obteni-dos en los experimentos descritos en este libro. No podemos dar cuenta de incidentes o daños sufridos por cosas, personas o animales que podrían producirse durante los experimentos llevados a cabo.

13

El mundo de Arduino

1

Con una pequeña placa electrónica surgida en Italia, cual-

quiera puede realizar múltiples circuitos electrónicos. Ardui-no o Genuino pueden utilizarse para el funcionamiento de

impresoras 3D, drones, prototipos interactivos. Su uso

no requiere grandes conocimientos y, además, una comunidad

entera está dispuesta a ayudaros.

Cuando todavía no había comprado mi primer Arduino, en 2008, leí Getting Started with Arduino, de Massimo Banzi. El libro me gustó mucho porque en él encontré varios as-pectos en común con el autor, que era también el padre de la famosa placa electrónica. Yo también empecé de niño a mostrar interés por la electrónica y la microcomputa-ción. En los años ochenta tenía un Spectrum 48K. Cuando abrí la caja, en el interior encontré también un manual de programación, porque en aquellos tiempos era habi-tual programar un ordenador. Eran los años de las revistas editoriales de electrónica, de los kits y de las tiendecillas de componentes para entusiastas. Tenía unos diez años cuando empecé a construir circuitos electrónicos traduciendo signos sobre el papel en objetos físicos. No sé cómo aprendí. Me ayudaron dos libros que todavía hoy con-servo: L'Elettrotecnica figurata [La Electrotecnia figurada] e Il manuale dell’inventore [El manual del inventor]. Eran libros ilustrados, para mi edad, que me fueron muy útiles. Aprendí a distinguir resistencias y condensadores gracias a aquellos libros y a muchos experimentos. Tenía un pequeño laboratorio en el sótano de la casa de Ceriano Laghe-tto: era el estudio de mi padre, que ocupé por completo y llené con todos mis cables

14


y ordenadores. Allí dentro, en mi pequeño «búnker», pasaba días enteros... y a veces incluso sus noches.A pesar de mis estudios en ingeniería de telecomunicaciones en el Politécnico de Milán, dejé de lado el laboratorio durante unos años, hasta aproximadamente 2006, cuando cayó en mis manos FAB, de Neil Gershenfeld, el cual volvió a encender las ga-nas de construir circuitos electrónicos. Mucho había cambiado en veinte años: nuevas y potentes tecnologías se encontraban desde hacía tiempo entre los estándares de mercado, muchas otras cosas se habían simplificado y los precios de la electrónica habían bajado drásticamente.En este largo período de tiempo, he asistido también a la explosión de Internet. Re-cuerdo mis primeras «navegaciones» durante las pausas entre clases del Politécnico: las sesiones eran en FTP y consistían en exploraciones manuales de enormes archivos online. Las direcciones se pasaban por voz; era como navegar con los ojos venda-dos. Unos años después, apareció el navegador textual Lynx para utilizar el protocolo HTTP: una extraordinaria novedad.Actualmente Internet se ha convertido en un medio de comunicación común y gene-ralizado y es de gran ayuda para quien quiere aprender algo o encontrar información. En mi laboratorio de Ceriano Laghetto, las únicas fuentes disponibles eran las revistas que conservaba ordenadas en grandes pilas y que conocía de memoria, además de al-gunos libros que había pedido que me regalaran y que describían las características de los transistores y de los circuitos integrados. Cuando podía, recuperaba componentes desmontando electrodomésticos y la mayoría de las veces conseguía partes que des-conocía por completo. Hoy en día basta con teclear las siglas de cualquier componen-te en Google para obtener una base de datos (es decir, una hoja de instrucciones). En Internet podemos encontrar también todos los esquemas electrónicos que necesita-mos y tutoriales y guías para aprender cualquier noción, tanto teórica como práctica. La vida para un «hobbista electrónico» moderno es mucho más sencilla, aunque sea un personaje en extinción. De hecho, aquellos que se interesan por esta materia ac-tualmente son solo los makers.En 2008 inventé una app para participar en un concurso de la provincia de Milán. La app servía a los deportistas para monitorizar sus entrenamientos y para proponerles retos reales o virtuales con otros runners. Para evitar que se llevaran con ellos el telé-fono, ideé un pequeño aparato con un hardware GPS que registraba los datos: un data logger o registrador de datos. Para realizar el prototipo compré mi primer Arduino, con la idea de conectarle los sensores necesarios.Quedé sorprendido de la simplicidad con que conseguí programarlo a la primera. Bas-taba con conectar la placa al PC con un cable USB, pulsar alguna tecla y cargarlo todo pulsando solo un botón.

15

El mundo de Arduino Capítulo 1

Desde entonces, he utilizado Arduino para muchos otros prototipos y proyectos. En 2011 empecé a impartir cursos para enseñar a utilizarlo. Creo que fui de los primeros en ofrecer en Milán cursos como L’elettronica della sciura Maria [La electrónica de la tía María] y el ABC di Arduino.

La historiaArduino1 nace en el Interaction Design Institute de Ivrea, un instituto de formación avanzada, posuniversitario, fundado por Olivetti y Telecom. Surge en un lugar espe-cial: en una ciudad que vio nacer (y crecer) la gran industria electrónica italiana, que por un momento nos hizo soñar a lo grande. Desgraciadamente, en Italia queda muy poco de aquellas grandes empresas y de aquel ingenio que sabían competir con las potencias mundiales y las multinacionales. Inventamos el ordenador personal, fuimos competidores de colosos como IBM, pero después algo se rompió: nuestro sistema político y económico ha ido consumiendo poco a poco todo lo que construyeron aque-llas importantes empresas nacidas en la posguerra y los emprendedores han dejado su sitio a directores especialistas en finanzas que las han ido corroyendo.No sé muy bien cómo fue la historia, pero dicen que en 2003 Hernando Barragán ha-bía desarrollado en Ivrea un proyecto original para acercar a diseñadores y creativos a la electrónica. Sería mejor decir: para facilitar el uso de la electrónica para la realiza-ción de productos innovadores e interactivos. El trabajo de Barragán se llamaba Wi-ring, siendo todavía hoy un proyecto activo. Wiring es una pequeña placa electrónica dotada de un chip que puede ser programado de forma muy sencilla con un ordenador y un programa derivado de Processing (un editor para simplifica la programación y el aprendizaje del lenguaje Java). Processing es un proyecto open source que ha sido modificado para programar Wiring y para funcionar con el lenguaje C requerido por la placa electrónica. Wiring y Processing «modificado» constituyen un sistema, o fra-mework, para la creación rápida de circuitos electrónicos. La escritura del código no se lleva a cabo en C puro, sino con una forma simplificada, ocultando detalles de la programación a bajo nivel: todo para facilitar el uso por parte de personas inexpertas.Massimo Banzi se interesó por el trabajo de Barragán y, en 2005, decidió desarrollar una nueva placa partiendo de la idea muy original de Wiring, tratando de simplificar al máximo el uso del sistema y disminuyendo el coste de la placa. El nuevo proyecto fue bautizado como Arduino, el nombre del bar de Ivrea donde el equipo del proyecto se reunía para tomar un aperitivo. El equipo que realizó Arduino estaba formado por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino y David Mellis. Desde

1 Esta historia es fruto de mi imaginación y de las fuentes encontradas en la Red. Nunca he podido entrevistar a los directamente interesados y espero que todo lo que cuento sea lo más fiable posible. Massimo Banzi e Hernando Barragán, ¡perdonadme si he escrito alguna tontería!

16


entonces, el proyecto ha obtenido un gran éxito entre los makers y mucho más allá. La pequeña placa de Ivrea ha sido adoptada por múltiples proyectos y ha permitido la realización de cosas hasta hace muy poco tiempo impensables, sobre todo por parte de personas sin conocimientos electrónicos.Así nace Arduino, una pequeña placa con un microcontrolador, que cualquiera puede aprender a utilizar en poco tiempo para realizar circuitos electrónicos interactivos. Para programar Arduino es suficiente con conectarlo al ordenador con un cable USB, escribir alguna instrucción, conectar algún componente electrónico y pulsar el bo-tón Upload. Se avanza mediante intentos y errores, corrigiendo el programa de vez en cuando. Las instrucciones son bastante simples y comprensibles. El software de programación, denominado también IDE (Entorno Integrado de Desarrollo), contiene múltiples ejemplos en los cuales inspirarnos para escribir nuestros propios códigos. Para facilitar la construcción de los circuitos electrónicos, se han inventado pequeñas placas, conocidas como shields, las cuales se apilan sobre Arduino. Existen shields con display, con un módulo Bluetooth, botones, controladores para motores, GPS, pla-cas de red, módulos de audio, etc. Sin tener que pelar ni un cable eléctrico, podéis construir un «bocadillo» de shields apiladas unas sobre otras y crear dispositivos muy sofisticados.Existen kits modulares formados por una shield madre que se conecta a Arduino y muchas placas pequenitas y pequeños cables que se conectan para componer los circuitos necesarios. Hay placas con botones, sensores de distintos tipos, motores, pantalla, LED, relés.Arduino ha triunfado porque es sencillo y siempre funciona. Porque normalmente en-contráis lo que necesitáis, sin tener que romperos demasiado la cabeza. Porque es un producto bien hecho y continuamente cuidado. La placa siempre se ha producido en Italia, y continuará siéndolo, y puede considerarse un verdadero producto Made in Italy.El proyecto didáctico se ha transformado en producto mateniendo la característica open source. Sin trampa ni cartón. Los esquemas del hardware se pueden descargar gratuitamente desde Internet, así como todo el software necesario para construir en casa, de forma autónoma, nuestro propio Arduino. Las empresas se vuelven, en muchas ocasiones, paranoicas con el tema de la segu-ridad y, si es posible, por tenerlo todo bajo llave. Para ellas, es inimaginable difundir por Internet los planos de un producto estrella. Arduino ha demostrado que, con las precauciones apropiadas, es posible crear empresas de éxito basadas en productos open source. La tutela está en la marca y la protección no está en la patente, sino en la respetabilidad del nombre y el producto: respetabilidad construida online gracias a la colaboración y la implicación de miles de makers.

17


Tras una reciente controversia sobre la marca Arduino, en todo el mundo, excepto en los Estados Unidos, la placa se ha vendido con el nombre de «Genuino», aunque fun-damentalmente es idéntica. En cambio, en los Estados Unidos, se ha comercializado con el nombre de «Arduino». También en Italia podéis comprar Arduino, pero se trata de la placa producida por la célebre Smart Projects, actualmente Arduino S.r.l. Esto, indudablemente, crea un poco de confusión, pero todo lo que encontraréis en este libro sobre Arduino puede aplicarse del mismo modo a las nuevas placas Genuino.

Microcontroladores y microprocesadores¿Que qué es un microcontrolador? Primero deberíais saber qué es un microprocesa-dor: es un circuito integrado (también denominado chip), especializado en la ejecu-ción de operaciones matemáticas, la transferencia y la manipulación de información. Estos chips son el cerebro de nuestros ordenadores y para funcionar necesitan me-morias, discos, periféricos de distintos tipos, ratones, teclados, pantallas. El primer microprocesador fue construido sobre los años setenta por Intel. El circuito producido por Intel se llamaba 4004, contenía un puñado de transistores y sabía desarrollar simples operaciones matemáticas de cuatro bits, con frecuencias de algún kHz. Los microprocesadores de hoy en día son grandes metrópolis comparados con el 4004: tienen centenares de miles de transistores y trabajan con frecuencias de GHz.Un microcontrolador es un chip que contiene un pequeño microprocesador y lo míni-mo imprescindible para su funcionamiento: memoria, algo que pueda funcionar como disco (flash memory), una memoria a largo plazo (EEPROM), un generador de fre-cuencia, convertidores analógico-digitales y sencillos periféricos para permitirles que interactúen con el mundo. Muchos microcontroladores tienen una potencia limitada, aunque también costes muy bajos. Por este motivo, los encontramos en muchos dis-positivos que utilizamos en nuestro día a día. Gracias a una serie de innovaciones introducidas por ATMEL y Microchip en los años noventa, su uso es muy sencillo, lo que contribuye a su difusión. Un microcontrolador moderno no requiere aparatos especiales para ser programado y el firmware puede ser transferido al interior incluso si ya se ha soldado sobre un circuito impreso. Antes de estas innovaciones, para uti-lizar un microcontrolador era necesario exponerlo a rayos ultravioletas para borrarlo y, a continuación, programarlo con kits de desarrollo muy caros. Los microcontrola-dores modernos tienen la posibilidad de alojar un pequeño programa, denominado bootloader, que reside en una área de memoria especial. El bootloader es un programa que puede escribir directamente las instrucciones en la memoria del chip. Así, no se necesita un programador particularmente complicado: con un simple puerto serie es posible programar el chip con el software que hemos escrito.

18


A menudo oiréis hablar de System On Chip. Con este término se designan los chips más complicados y completos de un microcontrolador. Son circuitos integrados que contienen, además de un microprocesador, también los circuitos para tarjetas de red o vídeo; son muy parecidos a un auténtico ordenador.Existen distintas familias de microcontroladores, que se distinguen por su nombre y la organización típica de sus circuitos internos, es decir, por la arquitectura del chip. La programación de estos chips se realizaba en código máquina, escribiendo largos pro-gramas que después se convertían en secuencias numéricas. Inicialmente, el número de comandos y de operaciones era limitado, se podían ejecutar simples operaciones lógicas, transferencias de datos y test. Con el aumento de la complejidad de los chips, los diseñadores empezaron a insertar operaciones más específicas y cada vez más complejas.Estos chips con un conjunto de instrucciones muy numeroso se denominan CISC (Complex Instruction Set Computer). Se trata de circuitos de grandes dimensiones, muy difíciles de diseñar y de realizar. Sin embargo, los programadores raramente uti-lizaban todas estas instrucciones complejas y, a veces, llevar a cabo la misma opera-ción en más pasos y con comandos básicos era incluso más rápido. Por ello, nacieron los chips RISC (Reduced Instruction Set Computer), en los cuales el conjunto de ins-trucciones se redujo al mínimo indispensable.Los procesadores RISC más conocidos son los PIC, los AVR, los ARM o los SPARC. El chip que utiliza Arduino Uno es un ATmega328 de la familia AVR. Más de una vez habréis oído hablar de los chips ARM (Advanced RISC Machine), que son circuitos utilizados en la fabricación de teléfonos, tabletas y dispósitivos móviles de bajo con-sumo y óptimas prestaciones.

ShieldArduino es modular. La placa electrónica cuenta con pequeños conectores a los que conectar cables eléctricos o componentes. Estos conectores presentan unos seis u ocho orificios, también denominados pines. Es posible acoplar a estos conectores pla-cas de expansión que respeten la misma disposición de contactos.Las shields son placas especiales para realizar funciones específicas. Para utilizar una de ellas basta con acoplarla encima de Arduino, creando así un «bocadillo» de placas. Se pueden apilar más placas siempre que se consigan controlar todas sin conflictos, puesto que cada placa ocupa un número determinado de pines. Las shields están de-sarrolladas y producidas por Arduino, aunque también otros conocidos productores de eléctronica para makers han creado placas compatibles: lo importante es respetar la disposición de los pines. Tenemos shields con pantalla LCD y botones, con Ethernet,

19


para la WiFi, para el Bluetooth, para controlar motores eléctricos, con GSM, con pan-talla e-ink, data logger con tarjeta SD y reloj e, incluso, shields para conectar dispositi-vos médicos. Simplemente debéis adquirir lo que necesitáis y acoplarlo sobre vuestro Arduino.Otra posibilidad para simplificar el desarrollo electrónico de circuitos es utilizar kits modulares, como TinkerKit o Grove. Estos sistemas están compuestos por una shield dotada de múltiples pequeños conectores. La shield se acopla sobre Arduino y hay otras placas pequeñas que pueden conectarse a la placa madre. Las conexiones se realizan con simples cables con conectores estándar. Cada pequeña placa monta un único componente o desarrolla una simple función. Tenéis a vuestra disposición pla-cas con un simple LED, un botón, placas con un relé, un potenciómetro, un sensor de temperatura, para el gas o la luz, etc. Para componer los circuitos simplemente debéis conectar a la placa madre cuanto necesitéis.

Maker & ArduinoLos makers enseguida apreciaron la versatilidad de Arduino y lo utilizan para realizar multitud de proyectos, compartiendo los resultados conseguidos, los esquemas eléc-tricos y el software. Algunos de estos proyectos son muy conocidos en Internet, otros se han convertido en startup. A continuación, os presento algunos trabajos que me han sorprendido especialmente. En cada uno de ellos, aunque alguno de vosotros note un cierto aire «de taller» o de prototipo, apreciad el espíritu de compartir y percibid la pasion de quienes han trabajado en ello. Estos makers (entre ellos, quien escribe) pasan horas y horas de su tiempo trabajando en proyectos que no siempre tienen una finalidad comercial. Las luces de nuestros sótanos (o de mi ático) están encendidas hasta muy tarde para poder trabajar en aquello que realmente nos apasiona.

Impresora 3DArduino ha tenido un papel importante en el desarrollo de las impresoras 3D open source: la mayoría de las placas electrónicas utilizadas actualmente en las impresopras procede de Arduino o de una de sus numerosas variantes. Para realizar una impresora con Arduino, se necesitan circuitos de accionamiento especiales para motores paso a paso denominados driver, unos cuantos transistores y termistores para controlar la temperatura. Muchas de las placas actuales en el mercado, como las RAMPS, derivan de una placa Arduino modificada, en la cual se ha integrado la electrónica necesaria para el funcionamiento de la impresora.

20


CNC y cortadora láserSi con Arduino puedo construir una impresora 3D, ¿por qué no una cortadora láser o una máquina CNC? Realmente, no son muy distintas y la electrónica podría, en al-gunos casos, ser aún más simple. Una CNC no tiene partes que se calientan y, como máximo, prevé un control de velocidad para un utensilio. Una sencilla cortadora CNC podría ser construida, por tanto, con tres motores para accionar los ejes X, Y y Z y un control de velocidad para el utensilio. El proyecto Lasersaur utiliza una placa que se conecta a Arduino para activar una máquina open source para el corte con láser.

DronesLos drones son pequeños helicópteros multicopters (es decir, dotados de más de una hélice) capaces de volar de manera muy estable y controlada. Sin embargo, se precisa una cierta «inteligencia» tanto para el control de los motores como para el de la esta-bilidad del helicóptero y Arduino es perfecto para gestionar los motores, el montaje, para leer un acelerómetro y otros sensores de orientación, así como para recibir ins-trucciones desde un radiotransmisor.También en este caso, después de los primeros prototipos creados con simples placas Arduino, han aparecido otras placas especializadas, siempre compatibles con la pla-taforma original. Así, es posible intervenir sobre el programa de control, modificando parámetros y comportamientos.

ArduFoninoCon Arduino es posible realizar un pequeño teléfono personalizado. No podrá ser un teléfono de reducidas dimensiones, pero es totalmente personalizado. Uno de los pro-yectos que se pueden encontrar en la Red se denomina ArduFonino y su creador es Davide Aloisi (http://www.davidealoisi.it/). En su sitio web explica el proyecto de esta forma: «ArduFonino es un teléfono móvil open source creado con Arduino, capaz de realizar y recibir mensajes. Con la realización de este proyecto, he querido sentar las bases para la construcción de un sistema telefónico elemental. La idea me surgió por pura curiosidad, porque quería hacer algo que nadie hubiera hecho nunca y demostrar a todo el mundo que querer es poder».El teléfono utiliza Arduino, una shield GSM con alojamiento para la SIM y una shield personalizada con pantalla, teclado, micrófono y altavoz. Es muy fácil conectar Ardui-no a otros dispositivos o sistemas utilizando shields Bluetooth, WiFi, GSM.

21


RobóticaPara aprovechar al máximo todos los conocimientos sobre Arduino, no hay nada más emocionante que aplicarlos en la construcción de un robot. Para un proyecto así, Ar-duino puede desempeñar la función de control, leer informaciones de los sensores y transmitir los movimientos a actuadores, tales como motores y servos. Hoy en día resulta sencillo construirse un robot DIY (Do It Yourself) o «Hecho por ti», sobre todo si disponéis de una impresora 3D para realizar todas las partes mecánicas. De no ser así, existen distintos kits «mecánicos» que se pueden comprar y completar añadiendo sensores, motores y otros dispositivos. El robot puede ser controlado remotamen-te por radio, pero el auténtico reto es conseguir que sea autónomo, programando la inteligencia artificial necesaria para que tome las decisiones adecuadas y para que se mueva por el mundo independientemente, evitando obstáculos y resolviendo pro-blemas. Arduino ha creado un kit robótico especial: un robot completo formado por dos placas, una de las cuales con dos ruedas motorizadas. Solo tenéis que añadirle un sensor y empezar a programar.

GarduinoSon muchos los proyectos en los que se ha utilizado Arduino. Basta con realizar una búsqueda en Google para sorprendernos ante la imaginación y el ingenio de muchas de las creaciones. Alguien ha pensado en utilizarlo para el cuidado de las plantas do-mésticas: la pequeña placa puede medir la humedad del terreno, la temperatura, la exposición solar y puede regar las plantas avisándonos con un correo electrónico. Existen muchos proyectos para controlar nuestro pequeño jardín: el más famoso es Garduino, actualmente conocido como Growerbot, un sistema para regar las plantas cuando es necesario, que puede también encender luces adicionales si la luz solar no es suficiente y puede avisarnos cuando las condiciones ambientales no son las ade-cuadas, porque hace demasiado calor o demasiado frío.El único límite es la imaginación, porque después, realmente, realizar el circuito no es tan complicado. Arduino puede ser utilizado también para reparar objetos que ya no funcionan. Yo lo he utilizado para ajustar el calentador de agua de una caravana: el fabricante cerró hace diez años y ya no se encuentran recambios, por lo que he susti-tuido la placa de control de la caldera con Arduino, conectándolo al sensor de llama, a los sensores de temperatura del agua y a la electroválvula para el control del gas.

Sitios de referenciaEl principal sitio de referencia es http://www.arduino.cc, aunque recientemente, tras una serie de problemas legales de los fundadores, se ha abierto el sitio «clon»

22


http://www.arduino.org. La batalla está abierta y no se sabe cómo acabará, pero el sitio original continúa siendo arduino.cc. Desde aquí podéis acceder al foro y a múlti-ples recursos en línea, como tutoriales, instrucciones para la programación, ejemplos de circuitos e informaciones de uso de las placas.Una búsqueda en Google nos hará descubrir numerosos recursos, sitios, blogs, tuto-riales, vídeos, artículos y libros. Y solo nos queda elegir. Sin embargo, si podéis, visitad un makerspace o uno de los Arduino User Group que existen: probablemente haya uno en vuestra ciudad. Encontraréis muchos otros apasionados como vosotros dispuestos a charlar un rato y a compartir sus experiencias. Los AUG organizan de forma perió-dica eventos y reuniones para ilustrar nuevos argumentos, proyectos y nuevas ideas. Normalmente, estas comunidades tienen una fuerte presencia online en las redes so-ciales como Facebook, Twitter y Google+.

23

En este capítulo veréis cómo está hecho Arduino, cuá-

les son sus partes fundamentales y qué funciones de-

sempeñan. Hablaremos de sus entradas y de sus salidas,

así como de los distintos modelos existentes.

Arduino es una placa con microcontrolador. Pero ¿qué es un microcontrolador? Este término se asemeja mucho a «microprocesador», pero no es lo mismo. Los ordenado-res que utilizamos en nuestro día a día, tanto en casa como en el trabajo, utilizan un microprocesador, es decir, un circuito integrado o chip, especializado en la ejecución de cálculos y en la elaboración de números e informaciones. Para funcionar, un micro-procesador necesita una o más memorias, un disco, algunos periféricos, una pantalla, un teclado y un ratón. Un microcontrolador, en cambio, es un pequeño ordenador: en su interior se encuentra un microprocesador y una serie de dispositivos integrados que funcionan como memoria, disco y periféricos para permitir su comunicación con el mundo exterior. Un microcontrolador necesita muy pocas cosas para funcionar: podría trabajar sim-plemente con los dos cables que le proporcionan la alimentación. La placa Arduino Uno utiliza un microcontrolador denominado ATmega328, producido por Atmel.Cargar un software en un ordenador es una operación muy sencilla, pero para hacer-lo con un microcontrolador se necesitan generalmente instrumentos especiales. En cambio, para programar Arduino se necesita solo un cable USB, porque de la progra-mación se ocupan un pequeño circuito, que se encuentra ubicado en la misma placa electrónica, y un programa especial precargado en el ATmega328. Así, todo es más fácil y la programación es sencilla y rápida.

Hardware

2

24


Arduino Uno (o Genuino Uno)No existe un único Arduino, sino muchos modelos, cada uno adecuado para exigen-cias concretas y con propiedades específicas. Seguidamente describiremos el modelo Arduino Uno: la placa más conocida y común, un poco más grande que un paquete de cigarrillos. Casi todos los otros modelos de Arduino presentan la misma disposi-ción de las conexiones, para que haya compatibilidad con las placas de expansión. Los pines de Arduino son accesibles sencillamente insertando cables eléctricos con las extremidades peladas en unas pequeñas filas de orificios denominadas header.

Figura 2.1 - La placa Arduino Uno (Fritzing).

Conector USBTiene una finalidad doble: se utiliza para alimentar la placa mediante los 5 V presentes en los puertos USB, pero también se puede usar para intercambiar datos con Arduino (función muy útil para entender qué está ocurriendo a bordo).

AlimentaciónEn un ángulo del circuito impreso podéis ver una pequeña clavija de color negro. En ella podéis insertar un jack de 5 milímetros (con un diámetro interior de 2,1 milíme-tros) para alimentar la placa. La tensión proporcionada será nivelada a 5 V por un re-gulador de voltaje. Hay mucha gente que conecta una batería de 9 V con un adaptador con jack para alimentar Arduino cuando no tienen un ordenador cerca.

25

Hardware Capítulo 2

GNDGND significa ground, es decir, «tierra» o «masa». Es el polo negativo de alimentación, también denominado «común» o «0 voltios». Entre los header de Arduino tenéis a vuestra disposición hasta tres posiciones para insertar conexiones a tierra.

5 VEste pin proporciona la tensión a 5 V regulada y estabilizada por Arduino. El estabili-zador interno puede proporcionar hasta casi 1 amperio de corriente.

3,3 VMuchos chips y sensores modernos se alimentan a 3,3 V, una tensión inferior respecto a los 5 V, que produce menos calor. No todos tienen en su caja de componentes un regulador de 3,3 V, razón por la cual sí que encontráis uno de estos en Arduino.

VINEste pin va conectado directamente a la entrada de alimentación y se puede utilizar para conseguir una tensión de alimentación más elevada, necesaria para hacer fun-cionar componentes conectados a Arduino. Imaginad que tenéis unos motores que funcionan a 12 V: para utilizarlos, alimentaríais Arduino a 12 V a través de la toma de alimentación y llevaríais la tensión de 12 V a los motores desde el pin VIN.

AREFArduino puede leer tensiones analógicas comprendidas entre los 0 y los 5 V que des-pués transformará en un número entre 0 y 1024. El paso mínimo, es decir, la precisión de la medida, será igual a 5 V dividido entre 1024, es decir, 4,88 milivoltios. Arduino utiliza siempre una tensión de referencia interna, obtenida de la tensión de alimenta-ción que podría no ser demasiado precisa y que debería valer 5 V (pudiendo encontrar sólo 4,8 V). Si queréis medir algo con mucha precisión, podéis utilizar una tensión de referencia muy estable y precisa aplicada en AREF. Si la máxima tensión analógica que queréis leer llega a los 3 V, podéis obtener una mayor precisión aplicando 3 V en AREF. De este modo, el paso mínimo será de 3 V dividido entre 1024, es decir, de 2,93 milivoltios. La tensión aplicada en AREF nunca debe ser superior a 5 V; de no ser así, corremos el riesgo de dañar a Arduino.

ResetLa placa cuenta con una tecla para resetearla. Al pulsarla, la ejecución del programa se detendrá y todo empezará de cero, como si acabáramos de encender a Arduino. Podéis conectar botones externos para ejecutar el reset.

26


PIN 0-13Arduino tiene 14 pines que pueden ser configurados para funcionar como entrada o como salida. La configuración se lleva a cabo en el software. Arduino es un dispositivo digital, por lo que los pines pueden generar o leer un valor alto o bajo y, por tanto, igual a 0 o 5 V. Un pin digital configurado como salida nunca podrá proporcionar, por ejem-plo, un valor de 2,5 V, sino solo de 0 o 5 V. Algunos pines muestran junto al número de identificación una pequeña onda denominada tilde (~): estos pines pueden generar una señal particular muy útil para hacer funcionar motores eléctricos o para ajustar la intensidad luminosa de un LED. Este señal eléctrico especial se denomina pulse-width modulation (PWM) y lo describiremos más adelante. Los pines que pueden proporcio-nar una señal PWM son: 3, 5, 6, 9, 10, 11.Los pines 0 y 1 aparecen también marcados como TX0 y RX0 y están conectados a los puertos serie del chip: pueden ser utilizados para conectar Arduino a cualquier otro dispositivo que disponga de un puerto serie.

A0-A5Arduino tiene seis pines capaces de leer niveles analógicos y convertirlos en un núme-ro que podrá ser utilizado dentro de los sketch. Estas entradas especiales se ubican a parte y están marcadas con las siglas A0, A1, A2, A3, A4, A5.

ICSPJunto al pequeño texto “ICSP” podéis ver seis pines que pueden ser utilizados para comunicarse con el ATmega328 y que constituyen una interfaz de serie utilizada por periféricos y otros microcontroladores. Los pines ICSP se pueden utilizar para progra-mar directamente Arduino mediante un lápiz especial. El sistema de comunicación se denomina SPI (Serial Peripheral Interface); cuenta con un circuito principal que con-duce la comunicación (master) y uno o más periféricos (slave).Dos de los seis pines se utilizan para la alimentación (5 y 0 V) y una línea sirve para seleccionar el periférico con el cual se desea comunicar. Los otros tres cables son:

• MISO (Master In Slave Out) – para enviar datos al master;• MOSI (Master Out Slave In) – por el cual pasan los datos para el slave;• SCK (Serial Clock) – la señal de sincronización (clock) para la comunicación.

De manera no demasiado intuitiva, para comunicarnos con un slave, debemos poner el pin a nivel bajo (0 V o GND).

27


ICSP2Junto al chip que se utiliza para la gestión de la interfaz USB, se sitúa un segundo conjunto de pines SPI. El chip es un pequeño microcontrolador que también necesita un programa para hacer funcionar el puerto USB. El programa de control se carga me-diante estos seis pines etiquetados como “ICSP2”.

¡Con una placa no tengo bastante!Arduino Uno es la placa más conocida, pero no es la única: en los últimos años, Ar-duino ha creado muchas otras placas para cubrir cada necesidad. Algunas de ellas han sido diseñadas en colaboración con otras organizaciones, como SparkFun2, Intel o Texas Instruments, y en ocasiones utilizan distintos tipos de microcontroladores o SoC, aunque la mayor parte de las placas se sirve de productos Amtel. Las posibili-dades para los makers son muy numerosas: existe una placa para cada necesidad, con distintos formatos, precios y capacidades. A continuación, os presento una breve descripción de los «Arduino» más famosos. Algunas de estas placas ya no se fabrican actualmente, pero si necesitárais una siempre podríais recuperar los proyectos open source y duplicarla.

Arduino Duemilanove, Diecimila, NG…La placa Arduino Duemilanove, fabricada precisamente en el año 2009, fue la proge-nitora de Arduino Uno. Antes de la Duemilanove, existieron otros modelos, como la Diecimila y la NG: estas placas no han sido solo prototipos, sino que han estado a la venta hasta hace muy poco tiempo. La Diecimila toma su nombre del hecho de haber vendido 10.000 placas: un auténtico éxito para una pequeña startup italiana llamada Arduino. Utilizaban todas un chip ATmega168, que fue sustituido solo en las últimas series de la Duemilanove por el ATmega328 por estar dotado de mayores recursos. Las diferencias principales residen en la comunicación con el ordenador necesario para la programación y en las contínuas mejoras aportadas al diseño del circuito y del producto. Las primeras placas utilizaban un puerto serie RS232, de aquellos con un conector de nueve pines, hace un tiempo presente en bastantes PC pero ahora impo-sible de encontrar. El puerto serie ha sido sustituido por un puerto USB, que necesita un chip especial (FT232), utilizado en los primeros modelos de Arduino y reempla-zado después por un sencillo microcontrolador Atmel ATmega8u2, adecuadamente programado.

2 SparkFun (www.sparkfun.com) es una empresa nacida en 2003 de la pasión de Nathan Seidle por la electrónica y con la intención de proporcionar placas, kits y conocimientos a los makers como él. Al principio, SparkFun revendía placas fabricadas por otras empresas, pero después empezó a diseñar y fabricar sus propios productos.

28


Arduino Mega 2560Cuando Arduino no es suficiente, podemos recurrir a Arduino Mega: ¡un Arduino Uno estrogenado! Cuenta con unos 54 puertos de entrada/salida, 16 entradas analógicas y 4 puertos de serie. Además, es compatible en la forma, las tensiones y la velocidad (16 MHz) con la placa Uno. Para poder ofrecer tantos puertos, utiliza un microcontro-lador ATmega2560. Existía una versión anterior a esta placa, simplemente denomina-da Mega, que contenía un ATmega1280.En estas placas, la gestión del puerto USB se confía a un segundo microntrolador, un ATmega16u2, y se realiza completamente mediante un software, no mediante un chip especializado y más caro, como se hacía antes.

Figura 2.2 - Arduino Mega 2560.

Arduino LeonardoArduino Leonardo es una placa muy parecida a Arduino Uno, pero con un microcon-trolador distinto: el ATmega32u4 en lugar del ATmega328P. Su pinout y la tensión de alimentación son completamente compatibles con Arduino Uno. La única diferencia es que, mientras que Arduino Uno utiliza un segundo chip para la comunicación USB y para la programación, en la placa Leonardo la comunicación USB es gestionada por completo por un único chip. Al conectarse a un ordenador, la placa Leonardo puede aparecer como un dispositivo HID, es decir, un ratón o un teclado, además de presen-tar el puerto serie para las comunicaciones y la programación. El precio de esta placa es ligeramente inferior al de Arduino Uno.

29


Arduino EthernetArduino Ethernet es una variante del clásico Arduino Uno, dotado de tarjeta de red Ethernet integrada. La tarjeta de red ocupa los pines 10, 11, 12 y 13, que, por tanto, quedan inutilizables. Sobre el circuito impreso podemos ver el alojamiento para una tarjeta microSD, en la cual pueden guardarse archivos y páginas HTML que un servi-dor web programable puede publicar en Internet.Arduino Ethernet no cuenta con un conector USB, por lo que para programar el micro-controlador es preciso utilizar un pequeño adaptador USB-serie, vendido por separa-do, que se inserta en un conector horizontal formado por seis pines. La placa ha elimi-nado la necesidad de añadir una Ethernet Shield a Arduino y ha representado el primer intento de crear un producto compacto para comunicar e intercambiar datos en red.

Figura 2.3 - Arduino Leonardo.

Figura 2.4 - Arduino Ethernet.

30


Arduino YúnArduino Yún (Yún significa «nube» en chino) (véase la Figura 2.5) es Arduino para el Internet de las Cosas. Yún une el clásico Arduino con un pequeño chip, oculto por una funda metálica, en el cual se ejecuta un sistema operativo GNU/Linux. Yún tiene una tarjeta WiFi integrada y una toma Ethernet y nace para ser conectado y facilitar las comunicaciones. El chip agregado es un SoC Atheros AR9331, es decir, un System On Chip: un pequeño ordenador sobre el cual se ha cargado una distribución GNU/Linux (OpenWrt). El sistema operativo Linux puede ejecutar tareas, programas, alojar un servidor web, publicar servicios web, ejecutar operaciones programadas y comuni-carse de forma sencilla con el ATmega con el cual comparte la placa.En cuanto se enciende, la placa Yún crea una red WiFi a la cual se puede conectar con un ordenador para configurarla y hacerla conectar a la red WiFi existente. Yún se programa con un cable USB o bien, una vez conectado a una red WiFi, directamente sin cables y, por tanto, en remoto.El ATmega y el Atheros se comunican mediante una librería especial denominada Bridge, que permite a Arduino invocar o publicar servicios, enviar correos electrónicos e interactuar con la Red de manera muy sencilla. Bridge facilita también la coope-ración entre ATmega y Linux: por ejemplo, directamente desde un proyecto (sketch) de Arduino podéis ejecutar programas presentes en Linux. El chip utilizado es un ATmega32u4 similar al que se utiliza en las placas Leonardo. Igual que estas, también Yún puede ser interpretado por un ordenador como un ratón o un teclado.La evolución de Arduino Yún es Arduino Tian («día» en chino), una placa con Blue-tooth Low Energy 4.0 y prestaciones mejoradas. La Tian no cuenta con el alojamiento para la tarjeta miniSD porque dispone de una memoria eMMC de 4 GB.

Figura 2.5 - Arduino Yún.

31


Arduino DueArduino Due se parece mucho a Arduino Mega, tanto que resulta fácil confundirse a causa de su aspecto prácticamente idéntico. Sin embargo, Arduino Due es mucho más potente porque utiliza un microcontrolador de tipo ARM (Cortex-M3 SAM3X8E de Atmel). El ARM trabaja a 84 MHz ante los 16 MHz de la placa Mega y tiene 32 bits en lugar de 8. Aunque sea muy parecida a la Mega, la mayor diferencia se encuentra en las tensiones utilizadas: Arduino Due trabaja a 3,3 y no a 5 V. Si por error se le conectan dispositivos o shields que aplican tensiones a 5 V en sus entradas, se corre el riesgo de dañarla de forma irreparable.A diferencia de las otras placas Arduino, la Due tiene dos salidas analógicas señaladas como DAC0 y DAC1. A estas salidas se conectan convertidores digitales-analógicos (DAC) con los cuales es posible crear señales analógicas auténticas para generar so-nidos o controlar otros dispositivos analógicos. Arduino Due puede utilizar una librería especial denominada audio library con la cual es posible reproducir con facilidad archi-vos de audio incluidos en una tarjeta SD.

Figura 2.6 - Arduino Due.

Arduino MicroArduino Micro utiliza un ATmega32u4 como la placa Leonardo. Es muy pequeño. Proporciona 20 pines digitales (in/out) y 12 entradas analógicas. A diferencia de los clásicos “Arduinos”, tiene una forma que permite insertarlo directamente en las bread-board. La pequeña placa tiene un puerto micro-USB que se utiliza para programarlo. El circuto impreso cuenta también con un botón para el reset y seis pines ICSP. La placa ha sido desarrollada en colaboración con Adafruit y es adecuada para realizar prototi-pos de pequeñas dimensiones.

32


Arduino NanoArduino Nano es todavía más pequeño que Arduino Micro. En un principio utiliza-ba el ATmega168, después sustituido por el ATmega328. Puede ser insertado en la breadboard y se programa mediante USB. Podría compararse con Arduino Duemilanove.

Arduino MiniEl Mini todavía es más pequeño que el Arduino Nano. Utiliza un ATmega328 y cuenta con 14 pines digitales y 8 entradas añalógicas. No dispone de ningún puerto serie y se programa utilizando un cable USB-serie que se conecta mediante jumpers a los correspondientes pines. Se utiliza cuando las dimensiones son muy críticas. La placa no tiene muchas protecciones y, por tanto, es preciso estar atentos a la tensión de alimentación, que no debe superar nunca los 9 V.

Arduino Pro MiniArduino Pro Mini utiliza un ATmega328: tiene 14 pines digitales y 6 entradas analógi-cas. No dispone de puerto USB y se programa mediante un cable USB-serie que se co-necta mediante jumpers a los correspondientes pines. Sus dimensiones son mínimas

Figura 2.7 - Arduino Micro.

Figura 2.8 - Arduino Nano.

Figura 2.9 - Arduino Mini.

33


y se puede utilizar también para prototipos e instalaciones permanentes. Arduino Pro Mini puede comprarse en dos versiones, una de 8 MHz y alimentada a 3,3 V y otra de 16 MHz alimentada a 5 V. La placa ha sido diseñada por SparkFun.

Arduino FIOSi queréis un prototipo wireless, Arduino FIO es la elección correcta. La placa puede alojar un transceptor XBee que puede comunicarse con una red de transceptores si-milares. FIO contiene un ATmega328P alimentado a 3,3 V para ser compatible con el XBee. La FIO tiene 14 pines digitales, 6 entradas analógicas y se programa con un ca-ble USB-serie (o FTDI Cable), o bien por radio utilizando un segundo XBee conectado a un ordenador. Ha sido diseñada por SparkFun.

Lilypad ArduinoCon Lilypad es posible integrar Arduino con vestidos y tejidos. La Lilypad nace para realizar prototipos y proyectos wearable, donde en lugar de cables eléctricos pueden utilizarse hilos textiles compuestos de seda y plata: los circuitos se trazan con hilo y aguja. Existen componentes especiales que pueden ser cosidos con facilidad, así como tejidos especiales que reaccionan al paso de corriente o capaces de funcionar como sensores: son los smart textiles o e-textiles. La Lilypad utiliza un chip ATmega168 con consumos muy reducidos. La placa tiene 14 puertos digitales que pueden ser utilizados como entradas o salidas y 6 entradas analógicas. Las Lilypad se programan mediante un cable convertidor USB-serie (FTDI).

Figura 2.10 - Arduino Pro Mini.

Figura 2.11 - Arduino FIO.

34


Existe una versión denominada Lilypad Simple que utiliza un microcontrolador ATmega328 pero con solo nueve pines digitales. Otra variante es la Lilypad Simple Snap que, en lugar de orificios, tiene botones de clip para facilitar el cableado. En la parte inferior de la Snap se coloca una pequeña batería de polímero de litio que se puede recargar conectando la placa a un cable FTDI.Las placas Lilypad han sido diseñadas por Leah Buechley y son distribuidas por SparkFun.

Lilypad USBLa placa de prototipado Arduino Lilypad USB incluye un conector micro-USB con el cual puede conectarse directamente a un PC: es posible programarla sin el cable FTDI. Esta variante de las Lilypad utiliza un ATmega32u4 que trabaja a 8 MHz.

Figura 2.12 - Arduino Lilypad.

Figura 2.13 - Arduino Lilypad USB.

35


Mega ADKLa placa Arduino Mega existe también en una versión para Android denominada ADK (Accessory Development Kit), para facilitar el desarrollo de accesorios para los dispo-sitivos con sistema Android. El ADK contiene una serie de especificaciones de Google para crear dispositivos compatibles con teléfonos Android3. Esta versión de Arduino utiliza un microcontrolador ATmega2560; se puede conectar de forma muy sencilla a un teléfono Android con un cable USB y gracias al chip MAX3421, sustituido después por un microcontrolador ATmega8u2 (como en las placas Leonardo). Arduino Mega ADK aloja un USB Host, para poderle conectar cualquier periférico USB.

Figura 2.14 - Arduino Mega ADK.

Arduino EsploraArduino Esplora se parece mucho a un controlador de videojuegos: tiene un pequeño joystick resistivo, pulsadores, LED, un micrófono, un buzzer, un acelerómetro y otros pequeños accesorios cableados y preparados para su uso. En Arduino Esplora es posi-ble añadir una pantalla LCD a color, generada y proporcionada por Arduino, para crear una consola personalizada de videojuegos. A diferencia de las otras placas Arduino, esta está dotada de un completo set de sensores y actuadores que hacen que esté lista para su uso.Esplora utiliza un microcontrolador ATmega32u4 a 16 MHz, el mismo que utiliza la placa Leonardo, el cual puede ser interpretado por un PC como un ratón o un teclado.

3 http://developer.android.com/tools/adk/index.html

36


Figura 2.15 - Arduino Esplora.

Arduino RobotEntre todos los proyectos que quien se acerca a Arduino desearía realizar está, sin duda alguna, un robot. Para hacerlo, necesitaréis ciertos conocimientos de mecánica (que podréis aprender leyendo un libro como Making Things Move – DIY Mechanis-ms for Inventors, Hobbyists, and Artists di Dustyn Roberts), además de algunos cono-cimientos de electrónica. Arduino os facilita las cosas y os ofrece un robot listo para usar: Arduino Robot, un pequeño autómata formado por dos circuitos impresos, con dos ruedas motrices y un surtido de sensores y actuadores útiles para realizar un ro-bot completo en poco tiempo. El robot está listo para su uso: basta con programarlo y ya puede salir a explorar el mundo. Arduino Robot cuenta con dos microcontroladores, uno para cada placa. La placa infe-rior, la que contiene los motores, se denomina Motor Board y la superior, Control Board. La placa con los motores se ocupa solo de la gestión de los movimientos y de los propios motores; la placa de control tiene la tarea de gestionar la inteligencia artificial necesaria para las estrategias del autómata. Cada placa se comporta como un único Arduino y se puede programar de forma independiente. Ambas placas utilizan un ATmega32u4. En el Arduino Robot encontraréis una pantalla LCD a color, cinco botones, una brújula, un slider, un lector de tarjetas SD, un altavoz y cuatro zonas para la prototipación, en las cuales es posible soldar componentes directamente sobre la placa.

Arduino TreArduino Tre utiliza un microcontrolador Sitara AM335x de 1 GHz (ARM Cortex A8 de Texas Instruments) y un clásico ATmega32u4. La placa es mucho más grande que Arduino puesto que se aproxima más al mundo de Raspberry y BeagleBone (con quien, entre otros, Arduino ha colaborado para la realización de la Tre).

37


Arduino Tre tiene un sistema operativo (GNU/Linux) y una salida de video HDMI: es un pequeño ordenador con 512 MB de memoria. La integración con Arduino permite el uso de las shields existentes y abre las puertas a otras posibilidades, sobre todo para el mundo de la impresión 3D y para los nuevos desarrollos en el campo del Internet de las Cosas.

Arduino ZeroEn 2014, en la Maker Faire de San Mateo (California), Arduino presentó los prototi-pos de una nueva placa, Arduino Zero, que aportó grandes novedades a la histórica plataforma. La mayoría de los productos basados en microntroladores AVR trabajan a 8 bits, pero Arduino Zero utiliza 32 bits. Así, es más sencillo utilizar datos de gran ta-maño o con números decimales. Esta placa utiliza un microcontrolador ARM de Atmel (ATSAMD21G18 ARM Cortex M0+).Arduino Zero es más rápido que el clásico Uno, de hecho, trabaja a 48 MHz, con una RAM de 32 kB y una tarjeta flash de 256 kB. Además, permite depurar los proyectos, utilizando para ello el Atmel Embedded Debugger (EDBG). De este modo es posible controlar aún mejor lo que ocurre en el microcontrolador e intervenir en los errores.

Arduino ProSparkFun, en colaboración con Arduino, ha creado una placa que ha denominado Ar-duino Pro. Esta utiliza el chip ATmega168 o bien, en el caso de los modelos más recien-tes, el ATmega328.

Figura 2.16 - Arduino Pro.

38


Está alimentada a 3,3 V y trabaja a 8 MHz, o bien a 16 MHz se si alimenta a 5 V. Es compatible con Arduino, pero no cuenta con el circuito USB-serie y, para la programa-ción, se debe utilizar una placa a parte que se conecta a una serie de pines horizonta-les. La placa no permite el montaje de headers: simplemente tiene unos orificios en los cuales es posible acoplar directamente cables a la placa. Arduino Pro puede alimen-tarse mediante la conexión FTDI o utilizando un conector para una batería recargable: un switch permite elegir la fuente de alimentación. Arduino Pro está distribuida por SparkFun.

Arduino BTEntre las muchas variantes de Arduino, no podía faltar la que cuenta con Bluetooth integrado. Arduino BT ha sido diseñada y distribuida por SparkFun en colaboración con Arduino, pero actualmente se encuentra fuera de mercado. Arduino BT utilizaba un ATmega168, después sustituido por un ATmega328. El módulo Bluetooth, Bluegiga WT11, estaba ubicado en un ángulo de la placa y esta podía ser programada sin cables (también porque no contaba con ningún conector USB). Arduino BT era compatible con todas las otras placas Arduino, pues presentaba la disposición habitual de los headers.La BT fue rápidamente suplantada por soluciones más modernas y potentes, como la Yún, que une el clásico ATmega328 con un SoC con sistema operativo y simplifica la comunicación de la placa con Internet.

Arduino GalileoIntel, líder en la producción de microprocesadores y chips, se ha unido con Arduino para realizar una placa que contiene un microcontrolador de la familia Pentium Intel Quark SoC

Figura 2.17 - Arduino BT.

39


X1000 de 32 bits. El X1000 puede trabajar a 400 MHz y 3,3 V o bien a 5 V, de manera que todas las shields para Arduino Uno sean compatibles también con la Galileo. Para la programación se utiliza el software de Arduino. La Galileo dispone también de un puerto miniPCI-Express al cual se pueden conectar los periféricos habitualmente utilizados en un PC. Entre sus características, se encuentran: un puerto Ethernet 10/100 MB, un slot para microSD, un puerto serie RS-232, puertos USB Host y Client y una tarjeta flash de 8 MB.

Figura 2.18 - La placa Arduino Galileo, producida conjuntamente con Intel.

Intel ha ido desarrollando otras interesantes placas pensadas para aplicaciones del Internet de las Cosas, como la pequeña y potente Edison, también compatible con el mundo de Arduino. Edison es una placa del tamaño de una memoria SD que puede ser utilizada sola o bien insertada en una breakout board especial, que la hace compatible con el entorno de Arduino y facilita el acceso a sus pines. La pequeña Edison utiliza un Intel Atom SoC Dual Core, junto con un módulo WiFi y un Bluetooth 4.0. En la Edison puede instalarse Linux (Yocto Linux) o Windows 10. La placa puede ser programada con el IDE de Arduino o utilizando Node.js, Python y muchas otras soluciones.

Arduino 101La placa Arduino 101 utiliza, en lugar del chip ATmega328, un Intel® Curie™. Por fue-ra es exactamente igual que un Arduino Uno; la diferencia fundamental está en las

40


tensiones de trabajo, que son a 3,3 V en lugar de 5 V y en una dotación de sensores integrados muy interesante. La 101 cuenta con un acelerómetro/giroscopio de seis ejes y con un módulo Bluetooth de baja energía (BLE). Gracias al Intel® Curie™, la pla-ca dispone de un núcleo x86 (Quark) y un núcleo ARC (Argonaut RISC Core). La 101 trabaja a 32 MHz y dispone de 196 kB de Flash Memory y 24 kB de RAM.

SanguinoPoco tiempo después de la aparición y el éxito de Arduino Uno, entró en el mercado la placa Sanguino, vinculada al mundo de las impresoras 3D (y de la cual ha derivado la placa Sanguinololu). Sanguino utiliza el microcontrolador ATmega644P, el chip más potente en formato DIL4 producido por Atmel. La placa tiene un mayor número de contactos y se coloca en un punto intermedio entre Arduino Uno y Arduino Mega; puede programarse con el software de Arduino. Trabaja siempre a 16 MHz, tiene 44 pines, 4 kB de memoria RAM, 64 kB de memoria Flash y 2 kB de memoria EEPROM.También se encuentra disponible el ATmega1284P, todavía más potente que el 644.

Arduino es AtmelLa mayoría de los productos Arduino utiliza microcontroladores producidos por At-mel. El más común es el ATmega328, utilizado para producir Arduino Uno. Atmel tiene una completa familia de microcontroladores ATmega, algunos con reducidas presta-ciones, otros con mayor número de pines y funciones integradas.

En la página siguiente podréis ver una tabla con las características principales de los chips comparando:

• Velocidad – la frecuencia de trabajo máxima del chip;• RAM – el tamaño de la memoria volátil, la que se utiliza para ejecutar cálculos

y operaciones;• Flash – la memoria que almacena vuestro programa. Funciona más o menos

como un disco;• EEPROM – la memoria permanente donde se guardan los parámetros o confi-

guraciones que no se deben modificar a menudo (sobre todo porque tiene un número reducido de escrituras);

• GPIO – indica el número de pines que pueden ser utilizados como entradas o salidas digitales;

• Pines analógicos – es el número de entradas analógicas que proporciona el chip. Estos pines corresponden a otros convertidores analógico-digitales, es decir,

4 Dual In Line, es decir, con los pines en doble fila y, por tanto, fácil de usar incluso en una breadboard.

41


circuitos internos del microcontrolador que transforman un señal analógico en un número entero que puede ser utilizado en vuestros programas;

• PWM (Pulse Width Modulation) – algunos pines pueden generar un determi-nado tipo de señal de onda cuadrada, muy eficaz para controlar el funciona-miento de motores y luces LED;

• Puertos serie – algunos microcontroladores ofrecen una o más líneas serie, útiles para intercambiar datos con otros dispositivos o para programar el propio chip;

• Alimentación – el intervalo de tensiones de alimentación admisible para el chip.

Estos chips pueden comprarse online en sitios como RS Components, Farnell, Mouser o DigiKey. Algunos de ellos, como el ATmega328, aún se producen en formato DIL, que puede ser utilizado con una breadboard. Añadiendo unos cuantos componentes más, podréis realizar una placa con microcontrolador personalizada con un coste mínimo.Si os interesa seguir por este camino, os interesarán, además de los chips de la familia ATmega, los ATtiny, sus hermanos pequeños, con funciones limitadas y precios mu-cho más bajos. Resultan óptimos para dar forma a vuestros prototipos creados con Arduino, porque el coste de un ATtiny puede ser inferior a un euro.

Tabla 2.1 - Tabla comparativa de algunos microcontroladores Atmel.

NombreClock

(MHz)RAM (kB)

EEPROM (B)

Flash (kB)

GPIOPines

analógicosPWM

Puertos serie

Alimentación (V)

ATmega168 20 1 512 16 23 8 in 6 1 1,8 – 5,5

ATmega328 20 2 1024 32 23 8 in 6 1 1,8 – 5,5

ATmega1284 20 16 4096 128 32 8 in 6 2 1,8 – 5,5

ATmega2560 16 8 4096 256 86 16 in 16 4 1,8 – 5,5

ATmega644P 20 4 2048 64 32 8 in 6 2 1,8 – 5,5

SAM3X8E (ARM) 84 64 + 32 16 384 2 × 256 103 16 in + 2 out 16 3/2 1,62 – 3,3

La electrónica no es mi fuerte: shield, TinkerKit y GrovePara realizar un prototipo con Arduino, no es necesario conocer a fondo la electrónica. Tener algún conocimiento no hace daño y, si andáis un poco perdidos en la teoría, os recomiendo que echéis un vistazo a mi libro Elettronica per maker – Guida completa [Electrónica para makers - Guía completa].Para empezar, necesitaréis una breadboard y algún componente electrónico, como re-sistencias, LED, potenciómetros y algunos sensores. Si queréis evitar el contacto con cables y resistencias, podéis comprar un Arduino Esplora, que se proporciona con un surtido mínimo de componentes y sensores.

42


Figura 2.19 - Un “bocadillo” compuesto por Arduino y una Data Logger Shield.

Arduino nace como sistema modular y todas las placas tienen un pinout determinado, sobre el cual se montan los headers, es decir, los conectores para unir rápidamente los circuitos impresos entre ellos. Los headers permiten llegar a todos los pines de Arduino. Una placa electrónica que respeta el pinout de los headers se denomina shield y se pue-de acoplar sobre la placa con el microcontrolador añadiéndole nuevas funcionalidades.Existen shields prefabricadas para ofreceros cualquier tipo de componente, sensor o sub-sistema. Las primeras shields fueron desarrolladas y fabricadas por Arduino, que dejaron paso a otras fabricadas por SparkFun o Seeed Studio y por muchos otros fabricantes de hardware. También existen shields «desnudas», dotadas solo de headers. Sobre estas podéis colocar a vuestro gusto componentes electrónicos para crear placas personali-zadas. Podéis apilar varias shields, una sobre otra, pero con límites. Cada shield cuenta con un número determinado de pines de Arduino y solo con dos placas podríais llegar al límite de las posibilidades. Al apilar las placas una sobre otra, formáis un «bocadillo».A continuación se describen algunas de las shields más comunes.

Ethernet ShieldHace unos años, cuando todavía no existían placas como Arduino Yún y no se hablaba demasiado del Internet de las Cosas, esta shield, equipada con un chip WIZnet, per-mitía comunicarse por Internet y hacer twittear las primeras cafeteras. La placa ocupa los pines altos, del número 10 al 13. Para utilizar las funciones de red, se han creado librerías y numeroso ejemplos, todos incluidos en el IDE. Las librerías se ejecutan a bajo nivel y las páginas web deben procesarse carácter a carácter.

43


WiFi ShieldCon esta placa podréis conectar Arduino a una red WiFi. Es bastante cara y es la al-ternativa wireless a la Ethernet Shield. Posteriormente han ido apareciendo pequeñas placas a menos de cinco dólares, para ofrecer conectividad a cualquier microcontrola-dor dotado de un puerto serie.

Data Logger Shield Un primer ejemplo de shield complejo es el que ofrece esta placa que une un reloj alimentado con una pila, que puede mostrar fecha y hora aunque Arduino no esté encendido, y un alojamiento para una tarjeta de memoria de tipo SD. Conectando la shield podréis registrar vuestros datos en los archivos guardados en la tarjeta SD. Podréis examinar el contenido de la placa extrayéndola o conectandoos por remoto, añadiendo una shield Ethernet, WiFi o Bluetooth.

GPS Shield Si queréis saber dónde os encontráis, podéis utilizar el sistema por satélite GPS para localizar con precisión los movimientos y la posición de vuestro Arduino. Existen dis-tintos módulos GPS, que comunican los datos mediante un puerto serie. Las coordi-nadas se envían en formato de texto. El GPS requiere una gran cantidad de energía para que funcione, por lo que necesitaréis un sistema de alimentación o baterías de alta capacidad.

GSM Shield Con una SIM GSM podéis acceder a distintos servicios de comunicación, para el inter-cambio de datos o SMS. La GSM Shield se puede utilizar también para realizar simples sistemas teléfonicos.

LCD ShieldLos LCD Shield más comunes tienen una pantalla de cristal líquido retroiluminado con dos líneas de una veintena de caracteres. Podéis escribir cualquier texto moviendo el cursor y enviando secuencias de caracteres. La pantalla va acompañada habitualmen-te por una serie de pulsadores para interactuar con el sistema. Las shield de este tipo generalmente se ubican en la parte superior del bocadillo. Para ahorrar pines digitales, los pulsadores pueden conectarse a los pines analógicos, en los cuales se leen inter-pretando las tensiones analógicas producidas.

44


E-Ink ShieldUna alternativa a las pantallas de cristal líquido son las pantallas de tinta electrónica, que se «imprimen» con textos e imágenes que se mantienen en el tiempo. Son panta-llas muy útiles para crear pequeñas señales o carteles semipermanentes. Las dimen-siones de las pantallas para Arduino son normalmente bastante pequeñas.

Motor ShieldNo es posible conectar directamente un motor eléctrico a los pines de Arduino. El motor necesita demasiada corriente y el microcontrolador no es capaz de proporcionarla sin dañarse. Para gestionar motores se necesita utilizar, por tanto, sistemas de control.El sistema más básico es un simple transistor (bipolar o MOSFET), pero también se pue-den utilizar soluciones más elaboradas que pueden controlar dirección y velocidad del motor. Además, existen placas especializadas para motores en corriente continua y para motores paso a paso. Estas placas simplifican las instrucciones necesarias para gestio-nar los dispositivos conectados y se comportan como el piloto automático de un jet.

PWM shield Cuando seis señales PWM no son suficientes, podéis utilizar una placa que puede gestionar decenas de PWM al mismo tiempo. Sobre estas placas, de hecho, encon-traréis chips especializados en la gestión de señales PWM. La colocación de estos últimos se lleva a cabo mediante una línea de serie y, también en este caso, el micro-controlador no debe ocuparse de la gestión contínua de las señales.

ZigBee ShieldEl sistema ZigBee es una variante del bluetooth de baja potencia (LE o BT 4.0) y está especializado para la domótica y las comunicaciones distribuidas. Utilizando muchas placas ZigBee se pueden crear redes de sensores distribuidas. Las placas se comunican con un puerto serie y necesitan un adaptador de corriente porque se alimentan a 3,3 V.

MIDI ShieldLa MIDI Shield tiene dos puertos MIDI que se pueden manejar con Arduino para crear eventos de sonido vinculados a sensores, uniendo sonidos y fenómenos físicos. ¡Las nuevas fronteras de la música! Si hubiera tenido una en sus manos Giorgio Moroder…

MP3 ShieldEs posible reproducir archivos mp3 con un simple microcontrolador: en la Red podéis encontrar varios experimentos. La descodificación de los datos de un MP3 no es sencilla,

45


por ello han sido creados chips especiales para su lectura. Una MP3 Shield tiene un alo-jamiento para una tarjeta SD y una salida de audio stereo con un jack de 3,5 milímetros. Conectad Arduino a una pantalla y ya habéis creado vuestro lector mp3 personalizado.

Breakout boardTambién existen soluciones diminutas: pequeñas placas en las cuales solo cabe un pequeño chip o un único sensor. Estas placas cuestan menos, pero deberéis cablearlas a vuestro Arduino utilizando cables eléctricos jumper. Si no queréis tener problemas de cableado y preferís una solución Plug and Play, optad por una shield.

Figura 2.20 - Pequeñas placas para microcontroladores: sensor de temperatura, driver para motores y módulo Bluetooth.

Como habéis podido ver, las shields son soluciones completas y listas para usar, pero bas-tante cerradas. Si no encontráis lo que necesitáis, no conseguiréis realizar vuestro proyec-to. A veces os podréis encontrar con incompatibilidades entre placas. Si dos shields utilizan los mismos pines, tendréis que eliminar una de las dos. Para los que buscan un término medio y desean cierta flexibilidad, existen soluciones modulares como TinkerKit y Grove.

TinkerKitSi queréis desarrollar prototipos interactivos con facilidad, sin tener que utilizar ni solda-dores ni breadboard, podéis recurrir a TinkerKit, el sistema modular para realizar circuitos electrónicos.TinkerKit utiliza una placa madre, una shield que se conecta a Arduino, cables de varias dimensiones y otras placas, cada una especial para proporcionar una función determi-nada. La placa madre está recubierta por numerosos pequeños conectores de tres con-tactos. Para construir un circuito, tenéis que conectar las pequeñas placas a la shield principal. Las placas disponibles son muchas: hay sensores y actuadores de todo tipo.

46


En el catálogo existen botones, LED, slider, potenciómetros, relés, pantallas, sensores para la luz, para la temperatura, detectores de gas, etc. Todo lo que podéis necesitar para realizar un prototipo: solo debéis conectarlo con los cables de longitud oportuna.Los conectores presentes en la placa madre se encuentran marcados con siglas, para que resulte fácil reconocerlos. Hay seis entradas analógicas marcadas de I0 a I5 y seis pines digitales conectados a los conectores que van de O0 a O5. Las salidas O se conectan a los pines PWM de Arduino.

GroveGrove es parecido a TinkerKit. Desarrollado y distribuido por Seeed Studio (http://www.seeedstudio.com/wiki/Category:Grove), es un sistema formado por numerosos pequeños bloques de expansión que se pueden conectar a una shield para Arduino. Cada elemento del sistema ofrece un única función, como un botón o un sensor de movimiento. Cada parte va acompañada de ejemplos y claras explicaciones acerca de su funcionamiento. Grove ha desarrollado dos kits, Mixer Pack5 y Mixer Pack 2, que no necesitan microcontrolador para funcionar y cuyos elementos pueden estar conecta-dos directamente entre ellos para realizar sencillos circuitos.

Figura 2.21 - El kit Grove.

5 La dirección web del Mixer Pack es http://www.seeedstudio.com/wiki/Grove_-_Mixer_Pack.

47

Abrid el envoltorio, extraed Arduino e instaladlo. En un mo-

mento podréis poner en marcha el entorno de desarro-llo que utilizaréis para cargar vuestro primer sencillo sketch

para hacer parpadear un LED.

Arduino no es solo una placa que podéis programar como os plazca, sino un sistema formado por:

• un circuito impreso con microcontrolador;• un software para programarlo;• una amplia comunidad online con la cual interactuar para recibir y dar soporte.

El punto de partida es el sitio web www.arduino.cc, donde encontraréis muchas in-formaciones útiles para empezar. Lo primero que hay que hacer después de desem-paquetar vuestro Arduino es visitar este sitio y descargar el software necesario para hacer funcionar la placa. El programa para utilizar Arduino con vuestro ordenador se llama Arduino IDE, o más brevemente Arduino. Un IDE es un entorno de desarrollo integrado (Integrated Development Environment): un nombre de fantasía para de-finir un editor avanzado enriquecido con muchos instrumentos útiles para escribir el software, probarlo y publicarlo o empaquetarlo (deploy). Algunos IDE conocidos, utilizados por muchos programadores, son Eclipse, NetBeans, Xcode y Visual Studio. Son programas complejos y especiales para escribir código Java, C, PHP, etc. Un IDE gestiona un compilador, es decir, el programa que recibe un código y lo traduce en bits comprensibles para microprocesadores y microcontroladores.

Instalación

3

48


Java y Processing

El IDE de Arduino está escrito en Java y basado en Processing (www.processing.org). Java es un lenguaje de programación inventado por James Gosling en 1992; inicialmente, estaba destinado a pequeños dispositivos y electrodomésticos, pero rápidamente fue apreciado por su versatilidad y, sobre todo, por la posibilidad de ser ejecutado en cualquier tipo de ordenador gracias a un intérprete denominado máquina virtual. Empezó a utilizarse para realizar sitios y aplicaciones para Inter-net. Actualmente está considerado un lenguaje histórico y ampliamente adoptado por un gran número de programadores.Processing es un entorno de desarrollo que nació con finalidades didácticas. se programa con un lenguaje muy similar a Java, enriquecido con algunas funciones de alto nivel para producir gráficos en dos o tres dimensiones. El software es open source con licencia GNU y se puede utilizar en Mac OS X, Windows y Linux. Los programas escritos en Processing pueden dialogar con Arduino; también es posi-ble combinar ambas plataformas, por ejemplo, creando un controlador de hard-ware que interactúe con un videojuego en ejecución en vuestro ordenador.

Processing (véase la Figura 3.1) fue utilizado como punto de partida para crear el en-torno de programación para Arduino. De hecho, la ventana principal de los dos progra-mas es muy parecida. Además, en Arduino no encontraréis el término «código» sino «sketch», heredado de Processing. Del sketch de Processing, el de Arduino hereda también la estructura caracterizada por dos bloques distintos, denominados setup y loop. Mientras que en Processing no es obligatorio utilizar bloques en los cuales insertar las instrucciones, en los sketch de Arduino debéis siempre incluir las dos secciones:

• setup, en la cual incluir todas las instrucciones que deben ser ejecutadas una única vez al encender Arduino;

• loop, con las instrucciones que se repiten hasta que Arduino es alimentado.

En un sketch de Arduino no pueden faltar nunca los bloques loop y setup.

Descarga e instalaciónEntrad en la dirección http://www.arduino.cc/en/Main/Software y descargad la últi-ma versión del software. En el momento en que escribo, la versión publicada es la 1.6.8 y está disponible para Windows, Mac OS X y Linux. Escoged la versión compatible con vuestro sistema y descargadla en una carpeta.

49

Instalación Capítulo 3

Figura 3.1 - La ventana principal de Processing.

WindowsEl procedimiento de instalación de Arduino es, en general, bastante sencillo. Si utilizáis Windows podéis consultar las instrucciones publicadas en el sitio de Arduino (http://www.arduino.cc/en/Guide/Windows).Para empezar, tomad la placa Arduino y un cable para conectarla a vuestro ordenador. El cable depende de la versión de Arduino que habéis comprado: para la placa más utilizada, Arduino Uno, necesitaréis un cable USB tipo A-B, de aquellos que se utilizan para las impresoras (véase la Figura 3.3). El conector USB macho tipo B tiene forma triangular, mientras que el conector macho de tipo A tiene una forma cuadrada, con dos bordes redondeados. En cambio, si tenéis un Arduino Mega, un Due o un Leonar-do, debéis utilizar un cable micro-USB: el cable que se utiliza normalmente para cargar teléfonos Android.Si la placa es nueva, enchufad el cable y controlad que el conector entre bien en su alojamiento. Si utilizáis los cables micro-USB, id con cuidado porque, aunque la toma micro-USB está soldada sobre el circuito impreso, es muy fácil romperla con una pe-queña flexión.

50


Conectad Arduino a vuestro ordenador: la placa debería encenderse. Todas las placas Arduino cuentan como mínimo con un LED que empezará a parpadear o a mostrar algun tipo de actividad. Probablemente, Windows detectará la presencia de nuevo hardware e indicará la búsqueda o la instalación de nuevos controladores6.

Figura 3.2 - Descarga del software para Arduino.

Figura 3.3 - Cable USB de tipo A-B, adecuado para Arduino Uno.

6 El «probablemente» es obligatorio dada la heterogénea variedad de configuraciones de hard-ware y versiones de Windows.

51


La descripción oficial del procedimiento de instalación, incluida en el sitio de Arduino, dice:

• conectad Arduino al ordenador y esperad a que Windows empiece el proceso de instalación de los controladores. La instalación fallará;

• abrid el Panel de control, id a Sistema y seguridad y después a Sistema;• en la ventana Sistema, abrid Administrador de dispositivos;• en la lista de hardware, buscad la opción Puertos (COM y LPT). Entre las opcio-

nes debería haber un puerto Arduino Uno (COMxx). Si no lo encontráis, buscad en Otros dispositivos o Dispositivos desconocidos;

• pulsad con el botón derecho del ratón sobre Arduino Uno (COMxx) y elegid Actualizar software de controlador;

• seleccionad Navegar por las carpetas para buscar el controlador;• navegad entre las carpetas donde habéis descargado y desempaquetado el

software de Arduino y localizad el archivo arduino.inf que encontraréis en la carpeta Driver (no en la carpeta FTDI USB Drivers). En las versiones antiguas de Arduino IDE (hasta la 1.0.3), el archivo se denomina Arduino UNO.inf;

• Windows reconocerá el driver y la instalación finalizará.

Ahora podéis poner en marcha Arduino pulsando sobre el icono que ha aparecido en Escritorio o en el menú de inicio.

Mac OS XPara OS X el procedimiento de instalación es todavía más sencillo. Podéis consultar las ins-trucciones publicadas en el sitio de Arduino (http://www.arduino.cc/en/Guide/MacOSX).Debéis haber descargado un archivo comprimido (.zip) en vuestro ordenador. Gene-ralmente, el archivo acaba en la carpeta Descargas o en el Escritorio. Descomprimid-lo con un doble clic y veréis aparecer el archivo Arduino.app: movedlo a la carpeta Aplicaciones. Con las nuevas placas, por lo general no tendréis que hacer nada más y tampoco tendréis que instalar ningún driver. Sí que necesitaréis los drivers si queréis utilizar una placa Duemilanove. En tal caso, los encontraréis en el sitio de FTDI (http://www.ftdichip.com/Drivers/VCP.htm).Iniciad Arduino con un doble clic sobre el icono que encontraréis en la carpeta Aplicaciones.

GNU/LinuxDesde la versión 10 de Ubuntu, Arduino se encuentra en los repository de sistema (Universe). Mediante Synaptic podéis localizar el paquete e instalarlo. Si no, abrid un terminal y escribid lo siguiente:

sudo apt-get update && sudo apt-get install arduino arduino-core

52


Tendréis que escribir vuestra contraseña porque estáis utilizando el comando sudo. Cuando finalice la instalación, encontraréis Arduino entre los programas instalados.Si el software no se inicia, quizás será necesario instalar Java. Instalad el paquete OpenJDK utilizando Synaptic o desde un terminal.Comprobad que vuestro usuario está en el grupo dialout, para poder tener los permi-sos para utilizar los puertos serie. Si no es así (o en caso de duda), acceded al grupo escribiendo:

sudo usermod -aG dialout paolo

Sustituid paolo con el nombre de vuestro usuario. Como alternativa, podéis iniciar Arduino desde un terminal utilizando el comando sudo:

sudo ./arduino

¡Hola LED!A continuación, cargaréis vuestro primer programa en Arduino. No os preocupéis si de momento no os doy demasiados detalles: en las siguientes páginas os lo explicaré todo. Este sencillo ejercicio práctico os servirá para saber si habéis instalado correcta-mente el software y si este se comunica con la placa.Vamos a cargar un código que hará parpadear un LED7. No tendréis ni que añadir un LED a Arduino, pues utilizaréis el que ya está en la placa, conectado al pin número trece.

7 Un LED es un componente electrónico que puede emitir luz como si fuera una lámpara, pero utilizando el efecto fotoeléctrico en lugar de la incandescencia de un filamento. La corriente en el interior de un LED circula en un único sentido. LED es una sigla que significa Diodo Emisor de Luz. Para más información, véase Paolo Aliverti, Elettronica per maker – Guida completa, Edizioni LSWR.

Figura 3.4 - Para el primer experi-mento solo necesitáis Arduino: uti-lizad el LED integrado en la placa (señalado con una L).

53


El sketch que hace parpadear el LED es el programa más sencillo que se puede cargar en Arduino para hacer algo visible, sin añadir partes electrónicas. El título de esta sección hace referencia al Hola Mundo de los programadores de software. Cuando se aprende un nuevo lenguaje de programación, se suele escribir un breve programa que muestra en pantalla el mensaje «¡Hola mundo!». En muchos libros de informática, los primeros capítulos contienen un sencillo ejemplo para realizar un programa de este tipo: de este modo, os hacéis rápidamente con el argumento y verificáis que todo funciona correctamente. Con Arduino sería difícil mostrar un texto en una pantalla... Lo más sencillo que podéis hacer y que se parezca a un saludo es hacer parpadear amigablemente un LED. Veamos cómo hacerlo.No tenéis que escribir un programa, porque en esta ocasión utilizaréis un ejemplo ya preparado, que si queréis podréis modificar. Esto es lo que tenéis que hacer:

• iniciad el entorno de programación de Arduino;• abrid el archivo de ejemplo Blink situado en File > Examples > Basics > Blink;

Figura 3.5 - El sketch para hacer parpadear el LED se encuentra en los ejemplos del menú File.

• se abrirá una nueva ventana con un nuevo sketch. Como ya hemos dicho, por ahora no os preocupéis demasiado por cuanto veréis escrito;

• conectad Arduino a vuestro ordenador;• comprobad que se encuentre seleccionado el puerto correcto consultando

Tools > Port. En Windows deberíais ver una opción tipo COMx (Arduino Uno); en Mac, tendréis algo como /dev/tty.usbmodemXXX, mientras que en GNU/Linux veréis /dev/ttyACM0 o /dev/ttyS0 o S1;

• comprobad también que el hardware que aparece en Tools > Board correspon-de a vuestra placa (por ejemplo, Arduino Uno);

• ahora, pulsad el botón Verify (el primero de la barra de herramientas);

54


• el ordenador trabajará durante unos segundos controlando vuestro código. Si todo ha ido bien y no surgen errores, en la parte inferior de la ventana, en la consola, deberíais ver solo texto de color blanco;

• pulsad Upload, el segundo botón de la barra de herramientas, para transferir el programa a la placa;

• si no surgen problemas de comunicación (habitualmente debidos a una selec-ción errónea del puerto serie), tras unos instantes, el LED número 13 de Arduino debería parpadear al ritmo de un segundo.

Figura 3.6 - Ventana de Arduino una vez cargado el sketch Blink. En la barra de herramientas veréis los botones Verify para controlar el código (1) y Upload para cargarlo en la placa (2).

Como Arduino sale de fábrica ya programado con el sketch Blink, no veréis diferencias evidentes. Sin embargo, ahora que sabéis cómo cargar un sketch, intentad editar el có-

55


digo y sustituir los números situados junto al comando delay. Sustituid 1000 por 100 y volved a cargar el sketch. No es necesario que volváis a conectar Arduino: modificad el sketch, pulsad de nuevo Verify y, después, Upload.A continuación, os muestro, en negrita, la parte del loop que tenéis que modificar:

void loop() digitalWrite(13, HIGH); delay(100); digitalWrite(13, LOW); delay(100);

Ahora el LED debería parpadear más rápido.Si las cosas van mal, comprobad en primer lugar el puerto serie: ¿es el correcto, se ha instalado correctamente? ¿El cable está bien fijado a la placa? ¿El LED se enciende? Y, por último, ¿habéis seleccionado la placa correcta?Para los más impacientes, en cambio, aquí tenéis una breve explicación del sketch. En el código hay comentarios, es decir, notas, que Arduino ignora, pero que os pueden servir para incluir informaciones de servicio en el programa o la descripción de su fun-cionamiento. Los comentarios en Arduino se muestran de color gris. Si un comentario ocupa una única línea, va precedido por una doble barra //, mientras que un comen-tario que se extiende por más de una línea empieza por /* y acaba por */. Se ignorará todo el texto situado entre los dos delimitadores.Al inicio del ejemplo Blink podéis ver un comentario de varias líneas:

/* Blink Turns on an LED on for one second, then off for one second, repeatedly.

Most Arduinos have an on-board LED you can control. On the Uno and Leonardo, it is attached to digital pin 13. If you're unsure what pin the on-board LED is connected to on your Arduino model, check the documentation at http://arduino.cc

This example code is in the public domain.

modified 8 May 2014 by Scott Fitzgerald */

Un poco más abajo, veis un comentario de una sola línea:

// the setup function runs once when you press reset or power the board

El sketch contiene dos secciones denominadas setup y loop. En la sección setup están las instrucciones de inicio de la placa, ejecutadas en el momento del encendido; en la

56


parte loop se encuentran las instrucciones que se repetirán hasta el infinito. Las sec-ciones están delimitadas por llaves.

void setup() //éste es el código de inicialización

void loop() //éste es el código que se repite

En la sección loop hay una única instrucción, pinMode, que sirve para modificar el com-portamiento del pin número trece. Cada pin puede comportarse como entrada o sali-da: esto lo decidís vosotros. Para encender un LED conectándolo al pin número 13, es necesario especificar que el pinout se comportará como una salida, escribiendo:

pinMode(13, OUTPUT);

Estad atentos a cómo escribís los comandos, puesto que es necesario respetar las ma-yúsculas y las minúsculas, sin olvidar incluir un punto y coma después de cada coman-do. La directriz pinMode sirve para modificar el comportamiento de un pin indicando el número de este último y el comportamiento que deberá asumir: INPUT o OUTPUT. Las instrucciones incluidas en setup se ejecutan solo en el momento de encender Arduino.En la sección loop podéis ver cuatro instrucciones que se repiten hasta que Arduino empieza a ser alimentado. La primera instrucción es digitalWrite, que sirve para hacer salir la corriente de un pin o para «encenderlo». La instrucción digitalWrite requiere dos parámetros: el primero indica el pin sobre el cual actuará y el segundo, qué tipo de comportamiento deberá asumir este pin, es decir, si se encenderá o se apagará. Un pin se enciende con HIGH y se apaga con LOW. Por lo tanto:

digitalWrite(13, HIGH);

enciende el LED conectado al pin 13 y lo mantiene encendido hasta nueva orden. La siguiente instrucción es delay, que se utiliza para interrumpir temporalmente la eje-cución del programa: es una pausa. El tiempo se expresa en milisegundos, de manera que un segundo es igual a 1000 milisegundos.

delay(1000);

Cuando Arduino encuentra un delay se detiene durante el tiempo indicado. En el sketch de ejemplo, habéis encendido el LED en el pin 13, y permanecerá así durante un segundo. A continuación, podéis ver la instrucción para apagarlo:

digitalWrite(13, LOW);

57


y después una pausa de un segundo:

delay(1000);

Después de esto, el ciclo se repetirá. Seguidamente os muestro el código completo:

void setup() pinMode(13, OUTPUT);


Una vez descargado en la placa, el sketch encenderá y apagará regularmente el LED a intervalos de un segundo, haciendo que parpadee: ¡Hola LED!La transferencia del sketch y la programación del microcontrolador son gestionados por un pequeño programa residente en un fragmento especial de la memoria de Ardui-no. Este programa se llama bootloader y está almacenado en una parte de la memoria flash del chip (la Boot Program Section). El sketch acabará en la Application Program Section de la memoria flash. El bootloader se despierta cuando llega un determinado código desde el puerto serie; el programa espera el nuevo sketch y, cuando llega, lo escribe en la Application Program Section. El bootloader se puede volver a escribir tam-bién a sí mismo.El sketch transferido a la memoria flash permanecerá allí incluso después de que Ar-duino se apague y allí lo encontraréis en cuanto lo volváis a encender, al menos hasta que no transfiráis un nuevo código (sketch).

59

Para utilizar Arduino no basta con saber conectar algún com-

ponente y copiar líneas de código. Es importante aprender a

programar y saber dividir un problema en partes más sen-

cillas. Un lenguaje de programación está formado por varia-bles, ciclos, condiciones, etc. Instrumentos que sirven

para resolver problemas de forma lógica y repetible.

La mayor parte de los manuales presentan los comandos básicos dejando a un lado el aspecto de la programación. He decidido incluir un capítulo dedicado a la progra-mación pura (que podría resultar difícil para algún lector) para cubrir este aspecto importante de Arduino, a menudo omitido. Este capítulo es solo una introducción a los conceptos esenciales.El lenguaje de los microcontroladores es el lenguaje C, definido a alto nivel, pero no demasiado sencillo como punto de partida para quien nunca se ha acercado al mundo de la programación. Algunos microcontroladores utilizan además lenguajes más difí-ciles, como el lenguaje assembler, que son muy parecidos al nativo de los microproce-sadores. Una versión más moderna del lenguaje C es el C++, que comparte con él la mayoría de los aspectos. Aunque el equipo de Banzi ha trabajado duro para simplificar y facilitar al máximo la programación de Arduino, el lenguaje que se debe utilizar es el C++ inmerso en un entorno que simplifica su uso.El lenguaje C se remonta a los años setenta, cuando fue utilizado para escribir el sistema operativo UNIX. Se hizo popular gracias al libro The C Programming Language, escrito por

Arduino y el lenguaje C/C++

4

60


Kernighan y Ritchie en 1978. Este lenguaje es potente y rápido, pero no muy sencillo de aprender para quien está empezando. Se necesitan conocimientos acerca del funciona-miento de ordenadores y de sus circuitos, además de una cierta formalidad en la escritu-ra de los programas. El C no cuenta con muchas instrucciones, pero es muy flexible: tan-to que se puede utilizar para escribir programas para casi cualquier tipo de dispositivo. Por ejemplo, también los teléfonos modernos con sistema operativo Android pueden ser programados en C, así como con el lenguaje Java. El software de muchos dispositivos hardware, utilizados en el sector industrial, está escrito en este lenguaje.Un programa en C está incluido en un archivo de texto con la extensión .c; el archi-vo debe ser procesado por un compilador: un programa especial que lee la lista de instrucciones presentes en el archivo y las traduce en el lenguaje del procesador. La secuencia de instrucciones también se conoce como código fuente. La traducción de un código a otro se denomina compilación.El lenguaje C es un lenguaje muy preciso, que no os perdonará nada: tendréis que seguir sus reglas sin equivocaros, si no obtendréis errores de compilación. Algunas de estas reglas son:

• todas las instrucciones deben terminar con un punto y coma (;);• se deben respetar los caracteres en mayúscula y minúscula;• existe un conjunto de palabras clave con las cuales se escriben los programas.

Las palabras clave son las bases del lenguaje. Debéis entenderlas como bloques básicos útiles para crear vuestros programas. Cada palabra tiene un significado determinado y unas reglas que definen su uso. Las palabras clave (keyword) de C no son muchas:

auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while

Las técnicas de programación han cambiado con el tiempo debido a los avances tecno-lógicos y al aumento de las prestaciones de los ordenadores. Los primeros programas in-formáticos estaban formados por listas de instrucciones que se ejecutaban en serie. Con los años, las exigencias han aumentado y este enfoque ha demostrado sus debilidades.Uno de los mayores problemas de un enfoque tan simple es que se aleja de la rea-lidad, porque quien programa habitualmente busca copiar de la mejor forma posi-ble los aspectos del mundo: de la realidad virtual a los procedimientos bancarios. El software trata de copiar hechos o procedimientos del mundo real con abstracciones, o modelos, que describen de la mejor manera los hechos y las cosas. Está claro que este enfoque no es sencillo de obtener con una secuencia lineal de instrucciones. Una aproximación de la realidad es aquella en la cual todas las cosas son objetos. Cada objeto tiene propiedades y sobre eso podemos desarrollar operaciones.

61

Arduino y el lenguaje C/C++ Capítulo 4

Estas reflexiones han hecho surgir los lenguajes «a objetos», que permiten crear pro-gramas con los cuales es más sencillo dar forma a los aspectos del mundo real. La di-ferencia principal del C++ respecto al C es precisamente esta: C++ se define como un lenguaje a objetos. Podéis definir un objeto «coche» y asignarle atributos, como peso, color, marca, cilindrada, número de marchas. Después, podéis tratar con el coche sin saber realmente cómo está hecho por dentro, es decir, qué tipo de software contiene.

El objeto «coche» pone a vuestra disposición también «métodos» para interactuar con él: podéis encender el motor, acelerar, frenar, cambiar de marcha, etc. Como ya hemos dicho, este tipo de enfoque facilita la separación del código: podríais no saber cómo está hecho el objeto ni querer saberlo, porque ha sido desarrollado por otras personas.

Aprender a programarAprender un lenguaje de programación no es tan difícil. Se necesita un poco de prác-tica para saber todo lo que se puede hacer con él y familiarizarse con su expresión, es decir, la mejor manera de traducir el proyecto de un programa en una serie de instrucciones. Hay lenguajes más o menos simples. Algunos requieren más forma-lidad, como el respeto de minúsculas y mayúsculas, el uso de paréntesis concretos, de espacios regulares o de signos de puntuación. A veces, estas formalidades son comprensibles y otras veces no lo son tanto, pero al final uno se habitúa y, cuanto más utiliza el lenguaje, las cosas parecen más naturales. Lo que es más complicado de aprender es el enfoque que hay que utilizar, sobre todo porque es fácil encontrar libros que enseñen un lenguaje de programación pero no libros que se ocupen de explicar cómo programar. La buena noticia es que, una vez se ha aprendido el método, podréis aplicarlo a cualquier tipo de lenguaje.Un programador debe entender el funcionamiento de un proceso, el comportamiento de un fenómeno o el método mediante el cual se deben modificar las informaciones, es decir, traducirlo en algo formal, para que un programa de ordenador pueda ejecu-tarlo de manera correcta. Para sacar adelante esta tarea, en ocasiones podría resultar

Figura 4.1 - El objeto «coche» está dotado de distintas propiedades.

62


útil saber algo acerca del funcionamiento de los ordenadores, pero en otras podría no ser tan importante.

Para empezar a escribir un programa, antes deberíais tener algún problema que re-solver. Os aseguro que si encendéis el ordenador y os sentáis delante de la pantalla, esperando una inspiración, vuestra carrera como programador acabará rápidamente.

Buscad una tarea para desarrollar.

Podría no ser tan sencillo, pero sin duda alguna es una cosa factible. Para aprender a programar en Android me he inventado una app para acordarme de los días de la se-mana en los cuales los servicios de limpieza pasan a retirar la basura. He encontrado un problema sencillo y he intentado resolverlo.

Una vez encontrado el objetivo, intentad entenderlo.

Ya sea con un problema simple o con uno complejo, tratad de definirlo y de delimi-tarlo. Si tenéis que escribir el programa de control para una máquina de café, limitaos a dicha tarea y respetadla: fijando los límites estáis definiendo el objetivo de vuestro trabajo. A veces, el objetivo no lo elegís vosotros, sino que lo impone el cliente, aquel que os está dando trabajo, o bien las condiciones físicas y tecnológicas.

Cómo funciona un ordenador

El modelo de computadora (u ordenador) que todos conocemos es aquel formado por una CPU (Central Processing Unit), memorias y una serie de unidades peri-féricas de entrada y salida. La CPU, o procesador, es la parte del ordenador que se ocupa de ejecutar las operaciones impuestas.

Figura 4.2 - Para interactuar con el objeto «coche» se utilizan métodos proporcionados por el programador.

63


La CPU recupera estas informaciones de un programa que normalmente está car-gado en la memoria RAM, es decir, la memoria volátil, que pierde su contenido cuando el ordenador se apaga. La CPU utiliza un marcador para acordarse de qué comando está procesando: este marcador se denomina program counter y es un contador. Cuando finaliza la ejecución de una operación, el valor del program coun-ter aumenta una unidad y se dirige a la siguiente operación. Las operaciones re-quieren que se copien datos en algunas celdas de servicio internas a la CPU. Estas celdas se denominan registros. Si la operación produce un resultado, este también queda almacenado en el registro.La CPU puede ejecutar operaciones aritméticas, operaciones para copiar datos de una parte a otra del ordenador y operaciones para comunicarse con los periféricos, es decir, cualquier dispositivo electrónico conectado al ordenador (como un ratón, un teclado, una tarjeta de video, una tarjeta de red, una impresora, etc.). Los peri-féricos se conectan entre ellos mediante un BUS, es decir, un conjunto ordenado de cables. Cada periférico, así como las celdas de memoria, tiene una dirección para poder ser interrogado por la CPU.

Una vez definido el objetivo, intentad conocer bien todos los aspectos de vuestro pro-yecto. Podéis ayudaros escribiendo y dibujando. Anotad y razonad vuestros apuntes; cuando todo esté claro, subdividid el trabajo en partes más pequeñas y, después, sub-dividid cada una de estas partes en subpartes. Este enfoque se define como top-down o, lo que es lo mismo, divide y vencerás, en memoria del modo de actuar en batalla de los antiguos romanos que, en lugar de intentar conquistar un país entero, procedían por pasos, adquiriendo cada vez pequeñas regiones. El enfoque opuesto se denomina bottom-up y supone que se parta de un paso pequeño completándolo antes de pasar al siguiente, para intentar después combinarlo todo: un procedimiento que tiene sen-tido si teneis dudas acerca de la factibilidad de alguna cosa. Sin embargo, a veces se combinan ambos enfoques.Hace tiempo, me pidieron que modificara un e-commerce incluyendo un envío auto-mático de correos electrónicos en la creación de documentos PDF. Como tenía dudas acerca de la factibilidad del trabajo, empecé desde abajo, desarrollando en primer lugar la parte para generar un simple documento PDF y para enviarlo por correo elec-trónico, y añadiendo después todo el resto (véase la Figura 4.3).

Subdividid el trabajo.

64


Los bloques que habéis identificado pueden ser dibujados utilizando simples rectán-gulos conectados entre ellos por líneas o flechas. Existe una formalidad incluso en este tipo de representaciones, pero no la utilizaré en estos ejemplos. Dibujad un bloque para cada actividad y, dentro del bloque, añadid un título o una breve descripción de su funcionamiento.

Figura 4.3 - El detalle de actividades que componen la tarea «preparar el café», la cual podría formar parte de la macroactividad «preparar el desayuno».

Puede que os sorprenda, pero no hay muchas posibilidades para combinar los blo-ques. Las principales configuraciones posibles (pattern) son tres:

• secuencias;• test;• ciclos.

La organización más sencilla que puede tener un trabajo es una secuencia de opera-ciones a realizar una tras otra. Para preparar un café tenéis que:

• elegir el café;• cargar la cafetera;• encender el gas;• poner la cafetera sobre el fuego;• esperar a que salga el café;• servir el café en las tazas.

El proceso de ejecución de un trabajo, paso a paso, se define como flujo.

65


Trabajar así es bastante natural porque, normalmente, conseguís llevar a cabo una ac-tividad cada vez. Hacéis lo mismo cuando cocináis siguiendo una receta paso a paso, ejecutando las operaciones en el orden en que se presentan. En una secuencia de operaciones es importante poder modificar el flujo de ejecución cuando se comprueban las condiciones. Podéis dibujar un bloque en el cual escribir el tipo de test a llevar a cabo: el bloque mostrará una o dos flechas de salida, según los test que realizará; el flujo de ejecución saldrá de una única flecha. Si hace demasiado calor, se enciende el ventilador.

El tercer tipo de configuración es la repetición de grupos de operaciones (ciclo). Esta es la razón por la cual nacieron los ordenadores.Para indicar un ciclo de operaciones, utilizad una flecha que sale del último bloque y apunta hacia el primero. Raramente un ciclo se repite hasta el infinito, por ello se incluye un test que interrumpe las repeticiones tras un cierto número de iteraciones, o al comprobarse una condición concreta.

Figura 4.4 - Una secuen-cia de operaciones.

Figura 4.5 - Un bloque que ejecuta un test.

Figura 4.6 - Un ciclo que repite dos operaciones.

66


El lenguaje C/C++8

Para aprender a programar en C/C++ os propongo utilizar un entorno de programa-ción online: en el sitio web www.ideone.com podréis probar inmediatamente todo lo descrito sin tener que instalar nada en vuestro ordenador.Ideone trabaja con numerosos lenguajes de programación. Antes de empezar a escri-bir el código en el área de texto, seleccionad el lenguaje correcto, es decir, C++, en el menú desplegable situado en la parte inferior izquierda.

Figura 4.7 - Ideone es un entorno de programación en C/C++ online.

El primer programaVais a escribir vuestro primer programa en C++: instrucciones para mostrar el mensaje de saludo “Hello World!”. Aunque el programa es muy sencillo, puede ser que os asustéis:

#include <stdio.h>

int main(void) printf("Hello C!"); return 0;

8 En realidad, no utilizaréis funcionalidades concretas de C++, por lo que todo lo que escribamos valdrá tanto para el lenguaje C como para C++. Sin olvidar que Arduino trabaja en C++, en las siguientes páginas utilizaré de modo intercambiable los dos lenguajes.

67


Copiad este código en el área de texto de Ideone. En C/C++ tenemos que ser muy precisos en la escritura de los programas. Por ejemplo, es necesario respetar las ma-yúsculas y las minúsculas. Para un compilador C/C++, escribir:

pinmode

es muy distinto a:

PINMODE

Cada instrucción debe ser completada con un punto y coma, aunque intuitivamente sería inútil. Comprobad siempre que todos los paréntesis se abran y después se cie-rren. También tendréis que utilizar llaves: las podeis escribir pulsando ALT GR + SHIFT + [ y ALT GR + SHIFT + ].Para compilar y ejecutar el código, pulsad el botón de color verde con el texto Run. Tras unos instantes, por debajo del área con el código, en la sección stdout, aparecerá el mensaje:

Hello C!

Figura 4.8 - El resultado conseguido con vuestro primer programa en C++: “Hello C!”.

La primera línea del código se conoce también como directiva:

#include <stdio.h>

68


Esta sirve para añadir al programa una librería (stdio.h) con funciones agregadas para escribir en pantalla. C/C++, de hecho, es un lenguaje potente pero magro: como ha-béis visto, está formado por pocas palabras clave y, para desarrollar operaciones más complejas, se utilizan librerías. La mayor parte de ellas son gratuitas y las más conoci-das ya están incluidas en el sistema.Todas las instrucciones del programa, sin embargo, deben ser escritas entre dos lla-ves. La primera está colocada después de la frase:

int main(void)

La palabra main debe aparecer siempre en un programa C/C++ ejecutable. La palabra int indica que el programa, al finalizar la ejecución, devolverá un número (el cual no nos interesa demasiado). La palabra clave void, encerrada entre paréntesis, indica que el programa no recibirá datos de entrada.Un programa ejecutable debe obligatoriamente devolver un número. Por ello, antes de la última llave, deberéis escribir:

return 0;

Devolveréis 0, que por convención significa «todo correcto». En realidad, podéis utili-zar el número que prefiráis. En el caso en que se detecten errores, es habitual que se devuelva un número negativo: -1.Para escribir un saludo, se debe utilizar printf, que no encontraréis entre las palabras clave de C/C++ porque es una función, es decir, un fragmento de código que se repite a menudo y al cual se ha asigndo un nombre comodín para evitar que se repitan inútil-mente conjuntos de operaciones. Una función recibe parámetros, ejecuta una tarea específica y puede devolver un re-sultado. El parámetro que recibe printf es el texto (denominado cadena) que se debe mostrar en pantalla.

printf("Hello C!");

No os olvidéis de finalizar todos los comandos con el punto y coma; si no, el código no funcionará y surgirán errores.Intentad ahora imprimir dos líneas de texto, utilizando dos printf, una detrás de otra:

#include <stdio.h>

int main(void) printf("Hello"); printf("World!"); return 0;

69


Probablemente, el resultado no es el que esperábamos: las partes “Hello” y “World!” están juntas y no en dos líneas. Para separar un texto, se debe utilizar el caracter especial \n (este caracter es único, pero tenéis que escribir la barra invertida seguida de la n). Escribid \n inmediatamente después de la palabra Hello. Ahora “Hello” y “World!” aparecerán en dos líneas distintas:

#include <stdio.h>

int main(void) printf("Hello\n"); printf("World!"); return 0;

Cuando un programa empieza a crecer y pasa a ser complejo, es una buena idea in-sertar descripciones o comentarios que posteriormente os ayudarán a recordar cómo funciona el conjunto. Hay escuelas de programación, en cambio, que afirman que los comentarios son una pérdida de tiempo y que un buen código no requiere el uso de notas ni descripciones añadidas para explicar aquello que debería ser evidente. Proba-blemente la verdad se encuentre en un punto medio.Podéis sentiros libres de incluir comentarios utilizando una doble barra inclinada se-guida de vuestras notas:

// aquí puedo escribir un comentario en una sola línea

Si necesitáis más líneas porque tenéis que escribir mucho texto, utilizad /* y */. Todo lo que se incluye entre los dos signos será ignorado por el compilador:

/*Tengo muchas cosas queescribir y no quiero que el compilador las lea…*/

Variables y tipos numéricosLos programas almacenan datos en las celdas de su memoria. ¿Cómo se inserta un dato en una celda de memoria? Dicho así, parece casi intimidatorio, pero en realidad es muy simple: se utilizan variables. Una variable es como un pequeño cajón en el cual se guardan informaciones. Son cajones tipificados, es decir, que pueden contener un tipo concreto de datos. El nombre de los cajones (variables) debe respetar unas reglas: no puede empezar con números ni caracteres especiales (por ejemplo, *, +, -, etc.). Por lo general, se pueden utilizar de forma indiferente mayúsculas y minúsculas.

70


Estos son algunos nombres de variables válidos:• temperatura

• i

• parametro123

• Nivel_de_gasolina

• VOLUMEN

Estos, en cambio, son nombres de variables no permitidos:• 12gamma

• nivel-del-gas

• *pippo

Una vez elegido el nombre, tendréis que definir qué tipo de información podrá con-tener vuestra variable. Una variable creada para almacenar números enteros podrá contener solo números sin coma, positivos o negativos: 0, 1, 2, -1, etc.Para definir una variable en C/C++, debéis escribir:

int nivel_gasolina = 10;

En primer lugar tendréis que indicar el tipo de número que será admitido en la va-riable, que en este caso es int, es decir, números enteros. Seguidamente, asignáis a la variable el valor 10, utilizando para ello el signo igual. Si queréis, podéis crear una variable sin asignar antes un valor:

int nivel_agua;

El compilador asignará un valor por defecto que podría ser igual a 0, aunque siempre es mejor no fiarse y asignar a las variables un valor inicial conocido (solo para no tener sorpresas). Además del tipo int, también existen long y byte. Un byte es un entero pequeño que puede contener valores que van del 0 al 255. El tipo long, en cambio, contiene números muy grandes que van del -2.147.483.648 al 2.147.483.647.¿Es posible utilizar números “con coma”? Sí, pero en los programas escritos para Ar-duino está desaconsejado porque consumen mucha memoria. Para definir uno de es-tos números se utiliza la palabra clave float seguida del nombre de la variable y, even-tualmente, del valor que se quiere asignar. Como separador decimal, no os olvidéis de utilizar el punto (.), como en el sistema anglosajón:

float tension_sensor = 1.12;

Los números float asumen valores del 3.4028235 × 10+38 al -3.4028235 × 10+38. Si se necesita una precisión mayor, se pueden utilizar los números “con coma” de tipo double.

71


Textos y caracteresLos textos y los caracteres se pueden memorizar mediante las variables. Podéis utili-zar una variable que contenga un único carácter o bien un texto entero o cadena. Por carácter se entiende un símbolo único, como el símbolo utilizado para la a o el símbolo que representa un número9. Una cadena, en cambio, es una secuencia de caracteres. En el lenguaje C, los caracteres se indican utilizando comillas simples. Esta es la defi-nición de una variable de tipo carácter:

char un_caracter = 'a';

En lugar del tipo int, esta vez utilizáis el tipo char.Para mostrar un carácter, utilizad la función printf con el marcador %c y la variable con el carácter que se debe visualizar. Así es como debe hacerse:

#include <iostream>

int main() char mi_caracter = 'a'; printf("El carácter es: %c", mi_caracter); return 0;

La variable mi_caracter es de tipo char y empieza con el carácter a. La función printf recibe dos parámetros: el texto que queréis visualizar, en cuyo interior se encuentra el marcador %c, y la variable que debe sustituir el marcador. printf utiliza %c para tratar de forma correcta la variable que le estáis pasando. Para mostrar números enteros, podéis utilizar el marcador %d.Ejecutad el programa y obtendréis:

El carácter es: a

Una secuencia de caracteres forma un texto que los programadores denominan tam-bién cadena, un concepto que en un principio no estaba presente en el lenguaje C, el cual utilizaba (y utiliza todavía hoy) secuencias de caracteres: imaginad un cajón con muchos compartimentos ordenados. Una cadena se define así:

char texto[] = "No tengo mucho que decir.";

Inmediatamente después del nombre de la cadena debéis insertar un par de corche-tes; el texto queda encerrado entre un par de comillas dobles. Para mostrar una cade-na podéis, por tanto, escribir un programa como el siguiente:

9 El “símbolo 1” es muy distinto al “número uno”. El símbolo es solo el signo gráfico que utilizamos para representar la magnitud matemática del valor correspondiente. Soy consciente de que este es un concepto casi filosófico.

72


#include <iostream>

int main() char palabras[] = "manzana pera miel azúcar"; printf("palabras al azar: %s", palabras); return 0;

Ejecutad el programa para mostrar en pantalla el contenido de la cadena. Para mostrar una cadena, debéis utilizar la función printf con el marcador %s.Se puede declarar una cadena indicando previamente su longitud:

char texto[5] = "hola";

La longitud útil siempre debe ser aumentada en un carácter respecto a los necesarios. Esto es así porque la última posición debe estar siempre ocupada por el carácter es-pecial \0 (denominado carácter nulo). Si no se indica explícitamente la longitud de la cadena, el compilador se ocupará de insertar el carácter nulo al final de la secuencia de caracteres, el cual sirve al ordenador para saber precisamente cuándo finaliza la cadena.Dado que una cadena es un conjunto ordenado de caracteres, podéis acceder a cada uno de estos caracteres indicando su posición:

#include <iostream>

int main() char palabras[5] = "hola"; printf("el tercer carácter: %c", palabras[2]); return 0;

En este programa hemos creado una cadena de cinco caracteres denominada pala-bras. printf mostrará solo el tercer carácter de la cadena.Para acceder a los caracteres individuales de una cadena, el índice empieza desde 0 y llega hasta el valor máximo, menos 1: en el ejemplo anterior, el índice va del 0 al 3.Arduino cuenta con un tipo String que facilita mucho las operaciones: no es necesario utilizar paréntesis o extrañas funciones para modificarlas. En seguida veremos cómo hacerlo, pero antes os dejo un anticipo sobre cómo definir una cadena:

String texto = "¡Así todo es más fácil!";

Para combinar dos cadenas, en Arduino basta con sumarlas:

String txt1 = "Hello";String txt2 = "World!";String testo = txt1 + txt2;

73


Sin embargo, en Arduino no podéis mostrar en pantalla las cadenas con printf.

OperacionesPodéis utilizar las variables para realizar cálculos matemáticos con los operadores de suma, resta, multiplicación y división. Sumad dos números enteros de esta forma10:

int suma = 10 + 2;printf("El resultado es: %d", suma);

También podéis llevar a cabo otras operaciones utilizando los operadores de sustrac-ción (-), multiplicación (*) y división (/). Cuando se realizan operaciones matemáti-cas, hay que estar atentos a los tipos numéricos que se utilizan. Si utilizáis solo enteros (int), el resultado será a su vez un entero. Intentad desarrollar la siguiente división:

int res = 10 / 3;

El resultado es igual a 3: se han perdido todas las comas porque los números enteros no las tienen. Para obtener un resultado más preciso, debéis utilizar el tipo float:

float res = 10 / 3;

También en este caso el resultado será incorrecto y de nuevo valdrá 3, porque estáis dividiendo números sin coma (10 y 3 son enteros), los cuales no pueden producir un resultado con coma. Para conseguir un resultado preciso, debéis explicar al compila-dor que todos los números que estáis utilizando son del tipo float: especificad la coma y los decimales, incluso si son igual a 0.

float res = 10.0 / 3.0;printf("El resultado es: %f", res);

En este caso, el resultado es igual a 3.3333.Para forzar un tipo numérico, podéis hacer un type casting (una conversión de tipo) escribiendo delante del número o de la variable el tipo en el cual queréis transformarlo:

float res = (float)10 / (float)3;

Array (o matriz)A veces, una simple variable no es suficiente y podría ocurrir que necesitárais tener que crear muchos «cajones» para memorizar múltiples informaciones distintas pero muy similares entre ellas en su significado.

10 Por brevedad, en los ejemplos siguientes no aportaré el código entero: lo podéis completar voso-tros añadiendo el include, el método main, las llaves y la instrucción return.

74


Veamos un caso simple pero concreto: calcular la media de cinco números. Para cal-cular la media, tenéis que definir cinco variables distintas, una para cada número, des-pués sumarlas y dividir el resultado entre 5. Llamad a las variables n1, n2, n3, n4, n5:

float n1 = 1.1;float n2 = 2.3;float n3 = 3.7;float n4 = 4.1;float n5 = 5.8;float media = (n1 + n2 + n3 + n4 + n5) / 5.0;

Es cierto que no es muy práctico tener que crear cinco variables distintas. Una matriz (array, en inglés) es como un cajón con compartimentos. El número de compartimen-tos está predefinido. Cread un cajón temperaturas para memorizar tres valores distin-tos:

float temperaturas[3];

Indicad el número de puestos disponibles (o compartimentos) añadiendo el valor, en-tre corchetes, justo después del nombre de la variable. También podéis no indicar el número de puestos y dejar vacíos los corchetes: en este caso, justo después del igual debéis listar los elementos de la matriz encerrados entre un par de llaves y separados por comas (,).

float temperaturas[] = 32.1, 30.0, 33.0;int estados[] = 0, 10, 2, 3, 1, 9;

Es posible crear una matriz vacía y modificar después su longitud mediante funciones especiales.El ejemplo para calcular la media de cinco números puede ser escrito de esta forma:

#include <iostream>

int main() float nn[] = 12.2, 1.2, 324.5, 34.8, 45.9; float media = (nn[0]+nn[1]+nn[2]+nn[3]+nn[4])/5.0; printf("media = %f", media); return 0;

Para acceder a un argumento de la matriz, debéis indicar su posición dentro del cajón utilizando el índice que empieza en 0. Si la matriz tiene cinco posiciones, el índice irá de 0 a 4. Para especificar el elemento deseado, se utilizan corchetes, situados después del nombre de la matriz.

float nn[] = 12.2, 1.2, 324.5, 34.8, 45.9;//para mostrar el tercer elemento

75


printf("tercer elemento = %f", nn[2]);//para mostrar el primer elemento, el índice es 0printf("primer elemento = %f", nn[0]);//para mostrar el último elementoprintf("último elemento = %f", nn[4]);

Para trabajar sobre las matrices, existen una serie de funciones específicas que no trata-ré en estas páginas (os aconsejo profundizar en ello online o con un libro sobre C o C++).

¿Será verdad?Una de las funciones principales y más importantes de un lenguaje de programación es poder «tomar decisiones», que en un lenguaje menos fantacientífico significa rea-lizar test. Es raro que un programa tenga un flujo continuo y regular desde el inicio hasta el final: con frecuencia se deben comprobar las variables o valorar condiciones, para después tomar decisiones. Para valorar una condición, es preciso ejecutar un test con un resultado verdadero o falso: no se admiten situaciones intermedias, porque estamos hablando de calculadoras lógicas o booleanos. Existen muchos tipos de lógi-ca, entre las cuales algunas especiales, más parecidas a nuestro modo de razonar y conocidas como lógicas fuzzy, donde no solo hay verdadero o falso sino que también se admiten situaciones intermedias o delicadas.En C/C++ podéis utilizar variables de tipo booleano, que admiten solo true y false como valores, o bien utilizar variables numéricas enteras. El valor true corresponde a 1 y false, a 0.

#include <stdio.h>

int main(void) bool test = true; printf("test = %d \n", test); printf("test = %d \n\n", !test); return 0;

En este ejemplo he utilizado una variable denominada test de tipo booleano (bool) y le he asignado el valor true. Después lo he mostrado en pantalla con printf. El resultado será: 1. La segunda función printf escribe el valor de test, negándolo (es decir, invir-tiéndolo). Para negar el valor de una variable booleana, debéis anteponer el símbolo ! que significa “no”. El texto !test significa, por tanto, “no test” o “lo contrario al valor de test”.Podéis realizar test solicitando al programa que verifique si una variable asume un valor concreto. Basta con utilizar un doble signo igual:

(i == 10)

76


Este texto devuelve true solo cuando la variable i vale 10. Podéis utilizar un test para hacer que vuestro programa lleve a cabo una acción específica. Si se verifica una de-terminada condición, el programa hará algo distinto. Utilizad if (si) para comprobar una condición; esta debe estar incluida entre paréntesis y la acción o las operaciones que serán ejecutadas van entre llaves.

int i = 10;if (i == 10) printf("i vale 10");

Si la instrucción que debe ejecutarse cuando se comprueba la condición es una sola, podéis omitir las llaves y utilizar una estructura más compacta:

int i = 0;if (i == 0) printf("i vale 0");

Evidentemente, podéis combinar distintas condiciones, encerrándolas entre parénte-sis y utilizando los operadores lógicos “y” (&&) y “o” (||). Para imprimir un mensaje si la variable i vale 10 y si j es igual a 5 tenéis que escribir:

int i = 10;int j = 5;if ((i == 10) && (j == 5)) printf("¡Correcto!");

Utilizad los paréntesis para separar las condiciones y ordenarlas.Para llevar a cabo una operación concreta, si una entre otras es cierta, haced lo si-guiente:

int i = 10;int j = 5;int k = 6;if ((i == 9) || (j == 5) || (k == 2)) printf("¡Correcto!");

El programa mostrará ¡Correcto! si solo una de las tres condiciones se verifica. Obvia-mente, podéis combinar entre ellos más operadores lógicos.Una operación puede incluir una alternativa: si se verifica algo en concreto, actúo de una manera, si no, actúo de otra. Este comportamiento se traduce en una estructura if… then y es como si vuestro programa estuviera en una encrucijada: si ocurre una cosa, voy hacia un lado y si ocurre otra, voy hacia el otro.

int i = 10;if (i == 5)

77


printf("i vale 5"); then printf("i no vale 5");

Si if… then puede compararse con una encrucijada, podéis crear más alternativas con if… else if… then:

int i =5;if (i == 0) printf("A \n"); else if (i == 5) printf("B \n"); else printf("C \n");

En programación, os encontraréis con distintos tipos de condiciones, por ejemplo, queréis comprobar si el valor contenido en una variable es mayor que uno:

if (temperatura > 30) //enciende el ventilador

El ventilador se encenderá cuando la temperatura sea superior a 30: por tanto, a partir de 31.Podéis comprobar cuándo una variable es mayor o igual que un número colocando el símbolo igual (=) después del de mayor que (>):

if (temperatura >= 30) //enciende el ventilador

El ventilador, en este caso, se encenderá cuando la temperatura sea igual o mayor que 30.A veces, puede ocurrir que tengáis una larga lista de else if. En estos casos, podéis utilizar el comando switch. Intentad ejecutar este ejemplo:

#include <iostream>

int main () int marcha = 1;

switch(marcha)

case 1 : printf("Se parte"); break;

78


case 2 : printf("has puesto la segunda"); break;

case 3 : case 4 : case 5 : printf("¡Brooom!"); break; default : printf("¿Qué marcha tienes puesta?"); return 0;

El comando switch ejecuta un test inicial sobre la variable marcha, y después hace saltar la ejecución del programa a la sección correspondiente. Cada sección está delimitada por case… break. Como podéis ver, se pueden agrupar varias secciones, manteniendo un break (es el caso de 3, 4 y 5). La última sección del bloque switch es predetermina-da, en la cual terminaríamos en el caso de situaciones no previstas: si marcha valiera -1, terminaríais en la sección default. Además, switch parece completamente equivalente a un código de if… then, pero es más rápido porque ejecuta un único test, mientras que el código de if requiere tantos tests como números de if existen.

Ciclos: repetir operacionesLos programas para ordenador son especialistas en repetir operaciones largas y abu-rridas. Para repetir una serie de operaciones no es necesario que ejecutéis varias veces un programa, sino que podéis realizar ciclos para que se repita un grupo de instruccio-nes un cierto número de veces, o bien hasta que no se verifique una condición deter-minada. El tipo de repetición más sencilla es aquella vinculada a la verificación de una determinada condición, donde el número de repeticiones no está predefinido. Podéis realizar un ciclo de este tipo utilizando la instrucción while. Después de la palabra clave while, se añade la condición que se debe valorar, entre paréntesis, y después un par de llaves con las instrucciones a repetir. El ciclo se repite hasta que la condición indicada entre paréntesis es cierta. Aquí tenéis un ejemplo:

int i = 1;while (i <= 5) i = i + 1; printf("i vale: %d", i);

La variable i está fijada en 1. La instrucción while verifica si i es menor o igual a 5; si esta condición se verifica, el programa “entra” en el ciclo y ejecuta el código presente

79


entre las llaves situadas después de while. La primera instrucción incrementa el valor de i, que ahora valdrá 2. El programa muestra un mensaje en pantalla y la ejecución vuelve al comando while. Ahora i vale 2: la condición se verifica y el ciclo se puede repetir. Cuando i valga 5, el programa entrará por última vez en el bloque while donde el valor de i aumentará hasta 6, mostrará el mensaje "i vale: 6" y, después, regresará a la instrucción while, que detectará la condición que falta y el programa ya no entrará en el bloque while y continuará con las instrucciones siguientes.Para abreviar, a menudo encontraréis la operación de incremento de la variable i en una forma “contraida” que gusta mucho a los programadores:

i++

El ciclo del ejemplo anterior podría ser escrito de nuevo así:

int i = 1;while (i <= 5) i++; printf("i vale: %d", i);

Con un ciclo while el número de repeticiones no está prefijado. Por este motivo, a veces se introduce una variable contador que memoriza el número de repeticiones:

int contador = 0;bool CONDICIÓN = true;while (CONDICIÓN) //en el ciclo ejecuto las operaciones //...

//después llamo a una función que comprueba si continuar o no CONDICIÓN = puedoContinuar();

contador++;

printf("Número repeticiones: %d", contador);

A veces es preferible ejecutar un grupo de instrucciones y después valorar, al finalizar la ejecución, si repetirlas o no. En estos casos, podéis utilizar el ciclo do-while:

int i = 1;do i++; printf("i vale: %d", i); while (i <= 5);

Esta vez, el programa entra de inmediato en el cuerpo del ciclo (el bloque que se repe-tirá), incrementa la variable i y muestra el mensaje, y después comprueba si ejecutar de nuevo el grupo de instrucciones.

80


Otro constructor muy utilizado es for, con el cual podéis repetir operaciones un núme-ro predefinido de veces. Para utilizar el ciclo for tenéis que especificar:

• la variable que se utilizará como contador;• un test para saber cuándo finalizar las repeticiones;• un modo de incrementar la variable contador.

Estas tres informaciones se codifican en C y siguen la palabra clave for:

for (int i = 1; i < 3; i++) printf("i vale: %d", i);

Inmediatamente después de for podéis ver un par de paréntesis en los cuales, sepa-rados por puntos y coma, se encuentran las tres informaciones necesarias para que el ciclo funcione. En primer lugar, se define una variable i que se utilizará como contador y se le asigna el valor inicial 1. Después se añade la condición de fin de ciclo: las re-peticiones continuarán hasta que el contador i será menor que 3. Por último, aparece el modo de incremento: la variable i se incrementará en una unidad cada vez. Las instrucciones que se deben repetir están encerradas entre llaves.El programa añade la instrucción for, crea una variable11 i y memoriza en ella el va-lor 1. Después descubre la condición de fin de ciclo (acabará cuando i sea mayor o igual a 3) y la modalidad de incremento de la variable (i++). Como i es menor que 3, el bloque de instrucciones que aparece entre llaves puede ser ejecutado (cuerpo del ciclo), y después el programa incrementa la variable i, que ahora vale 2, comprueba la condición (2 < 3) y vuelve a ejecutar el cuerpo del ciclo. En el siguiente paso, i vale 3 y la condición ya no se vuelve a verificar (3 < 3), por lo que el programa salta al final del ciclo for y continúa.Podéis modificar el “paso” sustituyendo i++ con la modalidad de incremento que pre-firáis. Podéis avanzar en pasos de dos unidades utilizando:

#include <iostream>

int main() for (int i = 1; i < 10; i = i + 2) printf("i vale: %d\n", i); return 0;

Ahora la modalidad de incremento es más comprensible: la variable i a cada paso será calculada añadiendo 2 a su valor.

11 La variable que utiliza el ciclo for como contador se crea solo la primera vez que el programa entra en el ciclo.

81


La variable “contador” también puede ser una variable preexistente y no es necesario definirla dentro de for, sino que debéis inicializarla siempre estableciendo un valor de partida. Por ejemplo, podéis escribir:

int i = 0;

for (i = 1; i < 10; i = i + 2) //cuerpo del ciclo for

Podéis modificar las repeticiones de un ciclo utilizando los comandos break y continue. El primero interrumpe el ciclo, mientras que el segundo interrumpe la ejecución de la iteración en curso. Ejecutad el siguiente programa:

#include <stdio.h>int main(void) for (int i = 0; i < 10; i++) if (i == 5) break; printf(" i: %d \n", i); return 0;

El ciclo for debería mostrar el valor de la variable i 10 veces. En el cuerpo del ciclo hay un test que comprueba si i vale 5 y después llama a break. De este modo, las 10 itera-ciones se interrumpirán la quinta vez y en pantalla podréis leer:

i: 0 i: 1 i: 2 i: 3 i: 4

La instrucción continue interrumpe solo la ejecución de la iteración actual, sin inte-rrumpir del todo la ejecución del ciclo. Probad este ejemplo:

#include <stdio.h>int main(void) for (int i = 0; i < 10; i++) if (i == 5) continue; printf(" i: %d \n", i); return 0;

Cuando i sea igual a 5, el programa saltará al inicio del ciclo y continuará con las ite-raciones que faltan. El resultado en pantalla será:

i: 0 i: 1 i: 2 i: 3 i: 4

82


i: 6 i: 7 i: 8 i: 9

Las instrucciones break y continue funcionan con cualquier tipo de ciclo, no solo con el ciclo for.

FuncionesUn modo intuitivo de programar es empezando a escribir los comandos uno después de otro, en una secuencia. Así es como se hacía antes, por ejemplo, utilizando lengua-jes como el BASIC, donde era necesario insertar los números de línea:

10 REM programa basic20 LET A = 1030 PRINT A40 GOTO 30

El BASIC también trabajaba con ciclos FOR o WHILE, pero teníais la posibilidad de ejecu-tar saltos utilizando las GOTO. Esta práctica no está muy bien vista por los programado-res más expertos, porque el uso de las GOTO complica el flujo del programa.Escribir programas como largas listas de instrucciones ha acabado siendo una prác-tica poco eficiente: puede funcionar en casos muy simples pero, en cuanto las cosas se complican, gestionar un programa con esta estructura resulta imposible. Sin duda alguna tendréis partes repetidas más de una vez, que no podréis gestionar con sim-ples «copia y pega».Imaginad que habéis duplicado varias veces un grupo de líneas que se ocupan de una operación repetitiva: leen la fecha de sistema y la presentan de un modo especial (día/mes/año). Al cabo de un momento, recibís la petición de modificar la manera en que mostráis la fecha: año/mes/día. Tendréis que repasar toda la lista modificando cada sección que contiene la fecha. Por casos de este tipo se introdujeron las funciones, con las cuales podéis aislar un grupo de instrucciones, atribuirles un nombre comodín, definir qué necesita para funcionar (los parámetros) y qué resultado dará.Para desarrollar una operación matemática, podríais definir una función que recibe dos números como parámetros y devuelve el resultado. En C definís una función así:

int operacion_matematica(int a, int b) int c = a * 10 + b; return c;

Para crear una función tenéis que:

83


• indicar el tipo de dato que devolverá la función (en este caso, int);• bautizar la función con un nombre unívoco y significativo (el nombre asignado

es operacion_matematica);• declarar los parámetros que se necesitarán como si fueran variables y encerrar-

los entre paréntesis inmediatamente después del nombre (int a e int b);• añadir el cuerpo de la función, es decir, las operaciones que deberá llevar a cabo;• devolver el cálculo ejecutado utilizando la palabra clave return (en el ejemplo,

ha sido devuelto el valor de la variable c).

Podréis volver a llamar a la función desde cualquier punto, indicando sus parámetros y guardando el resultado en una nueva variable. La función se guardará en una parte de la memoria y, cuando el ordenador llegue a operacion_matematica, se marcará el punto alcanzado, saltará a la parte de la memoria en la cual se ha guardado la función, la ejecutará y regresará al punto en que se había quedado, devolviendo el resultado calculado por la función.En la Figura 4.9 he intentado representar gráficamente este caso con el código sin funciones y el código con funciones. En el código de la derecha hay un grupo de líneas (1) que se repiten varias veces en distintos puntos del código. La situación se puede mejorar introduciendo una función (3) que contendrá las líneas de código repetido. La función será llamada de nuevo por más partes incluidas en el código (2).

Figura 4.9 - Representación gráfica de un programa con código repetido (1) y de un código que utiliza una función (3) llamada en distintos puntos del código (2).

84


Para utilizar la función basta con escribir su nombre y proporcionar los parámetros necesarios. Podéis pasarle directamente números y cadenas, o bien variables.

int valor = operacion_matematica(4, c);

Si la función no devuleve un valor de retorno, es suficiente con invocarla:

enciende_impresora("impresora en el pasillo");

Una función también puede contener parámetros.

int numero_vencedor() int c = numero_al_azar(); return c;

Una función puede no devolver ningún resultado y, en estos casos, se llamaría proce-dimiento. En este caso, la primera palabra que debe escribirse antes del nombre de la función es void, la cual indica que no se devolverán resultados. En el cuerpo de la función no se puede utilizar return porque no se devuelve nada.

void invia_ping (String str) WebClient.ping(str);

¿Dónde se colocan las funciones? En C/C++ las podéis definir dónde queráis, al inicio o al final del código, siempre que al inicio haya siempre la definición de la función, es decir, la descripción de la función sin el cuerpo. Podéis insertar la función completa al inicio del código, como en el ejemplo siguiente:

#include <stdio.h>

int suma(int a, int b) return a + b;

int main(void) int res = suma(10, 5); printf("suma = %d \n", res); return 0;

85


La función suma se sitúa al inicio del código, fuera del método principal main. Si lo pre-ferís, para una mayor «limpieza», podéis insertar solo la declaración de la función y después poner el cuerpo dónde queráis, como en el ejemplo siguiente:

#include <stdio.h>

int suma(int a, int b);

int main(void) int res = suma(10, 5); printf("suma = %d \n", res); return 0;

int suma(int a, int b) return a + b;

La función suma no se ha repetido: el compilador debe saber que la utilizaréis y se con-tenta con tener una única declaración de cómo será. El cuerpo completo de la función se puede colocar al final del código e, incluso, en un archivo aparte.

87

En este capítulo aprenderéis las nociones fundamenta-les y las instrucciones básicas para configurar los pines de

Arduino. Veréis cómo encenderlos y apagarlos, cómo

generar señales eléctricas y qué hay que hacer para inter-pretar señales analógicas y digitales.

En este capítulo aprenderéis las bases de Arduino, es decir, los comandos esenciales para crear la mayor parte de los proyectos. Os sorprenderá, pero los comandos funda-mentales son solo cinco:

• pinMode – para configurar los pines de la placa;• digitalWrite – para encender un pin;• digitalRead – para interpretar el estado de un pin;• analogWrite – para crear señales variables;• analogRead – para interpretar señales analógicas.

El sketchEl punto de partida de cualquier proyecto con Arduino es el sketch, es decir, el código, que como ya sabéis está organizado en dos secciones principales:

• setup – ejecutado solo al encender la placa o después de pulsar la tecla RE-SET;

• loop – que contiene las instrucciones repetidas continuamente hasta que Ardui-no es alimentado.

Programar Arduino

5

88


El sketch se configura de esta forma:

void setup() //código después del encendidovoid loop() //código repetido

Debéis aseguraros de incluir siempre las dos secciones setup y loop; si no, surgirán erro-res. setup y loop son dos funciones que no devuelven ningún resultado y no necesitan parámetros, por lo que van precedidos de la palabra clave void.Podéis cargar un sketch en blanco pulsando la opción del menú File: Ejemplos > Basic > BareMinimum.Es obligatorio crear un sketch con loop y setup, pero no lo es insertar código dentro de estas dos secciones. Podríais tener un sketch con código solo en la sección loop, o bien en la parte setup (de manera que se ejecute sólo una vez). También podríais cargar un sketch vacío en Arduino y limpiarlo de programaciones anteriores.

Cómo cargar un sketchEn el siguiente párrafo os muestro el procedimiento que hay que seguir para cargar un sketch en Arduino. Esta es la secuencia de operaciones que tenéis que repetir cada vez:

• iniciad el entorno de programación de Arduino;• escribid vuestro sketch en la ventana del programa;• montad el circuito eléctrico y conectadle Arduino;• conectad Arduino a vuestro ordenador mediante el cable USB;• comprobad que está configurado el puerto correcto en Tools > Port. En Win-

dows encontraréis para ello la opción COMx (Arduino Uno); en Mac veréis algo como /dev/tty.usbmodemXXX, mientras que en GNU/Linux encontraréis /dev/ttyACM0 o /dev/ttyS0 o S1;

• comprobad también que el hardware configurado en Tools > Board corresponde a vuestra placa (por ejemplo, Arduino Uno);

• pulsad el botón Verify (el primero de la barra de herramientas) (véase la Figura 5.1);

• el ordenador empezará a trabajar durante unos segundos comprobando vues-tro código. Si todo ha ido bien y no surgen errores, en la parte inferior de la ventana, en la consola, deberíais ver solo texto de color blanco;

• pulsad Upload (el segundo botón de la barra de herramientas), para transferir el programa a la placa (véase la Figura 5.2);

• los LED TX y RX parpadearán unos instantes hasta que todo el programa se haya transferido a la placa.

89

Programar Arduino Capítulo 5

Figura 5.1 - La ventana de Arduino con el botón de comprobación del sketch seleccionado.

Figura 5.2 - La ventana de Arduino con el botón Upload para cargar el sketch seleccionado.

No os preocupéis si os parece que hay muchos pasos en el procedimiento de carga, pues, una vez hayáis cogido confianza, será un momento. Al finalizar la transferen-cia, en la parte inferior de la ventana, encontraréis indicados el tamaño en bytes del sketch, el espacio ocupado en memoria en porcentaje y otras informaciones similares.

Figura 5.3 - Mensajes presentes en la parte inferior de la ventana de Arduino después de una carga sin errores.

Si ha surgido algún error en la fase de comprobación o durante la carga, en la parte inferior aparecerán mensajes de color naranja con indicaciones útiles para resolver los problemas. En caso de errores de escritura del código, se mostrará la línea en la cual se ha identificado el error. Al cargar un sketch en Arduino, podrían producirse problemas de transferencia: habitualmente estos errores se deben al puerto serie, que

90


podría bloquearse, o bien al cable, que no hace buen contacto, o en ocasiones a algún problema con el circuito conectado a Arduino. En estos casos, probad a desconectar la placa, guardar el código, apagar completamente Arduino y volver a empezar de nuevo. A veces, también puede ser necesario reiniciar el ordenador para resolver la situación. Un error común se produce cuando vuestro circuito utiliza los pines número 0 y 1, los cuales están compartidos con el puerto serie conectado al ordenador: para cargar correctamente el sketch, deberíais desconectar temporalmente los componentes que habéis conectado a estos pines, porque todo lo que está conectado en los pines 0 y 1 puede interferir en la carga de los sketch.

Figura 5.4 - Mensajes de error en la parte inferior de la ventana de Arduino: se ha detectado un error en la línea 8, columna 5 del sketch.

Breadboard

Una breadboard es un tablero especial para construir rápidamente prototipos elec-trónicos. No es necesario utilizar un soldador. El tablero está hecho de material plás-tico y cuenta con múltiples orificios en los cuales se insertan componentes elec-trónicos y cables de conexión (denominados jumper). Los orificios se agrupan en patrones de líneas y están en contacto eléctrico entre ellos, de manera que, si se in-sertan los pinouts de dos componentes en la misma fila, estos estarán en contacto.Las breadboard se fabrican en varios formatos, pero siempre están divididas en dos mitades por un surco central. Podríamos hacer una analogía con el agua, en la cual los cables eléctricos serían tuberías hidráulicas, los cinco orificios de una línea de la breadboard son comparables a un tubo de conexión con cinco vías: introducien-do el agua por un agujero, podéis descargarla por otro de los existentes. El nombre «breadboard» procede de la analogía con un tipo de cuchillo para el pan formado por una bandeja sobre la cual hay una rejilla con orificios rectangulares. Al cortar el pan, las migas se recogen en la bandeja inferior pasando por los agujeros.

91


Las breadboard son muy útiles para realizar circuitos rápidos, pero no siempre ga-rantizan creaciones estables y fiables: es muy fácil generar un falso contacto o un cortocircuito. Un circuito dotado de numerosos «cables volantes» no tiene buenas prestaciones y los ruidos y las interferencias pueden volverlo inestable.El circuito será tan inestable cuanto mayor sea su frecuencia de funcionamien-to.

Figura 5.5 - Una breadboard “half-size”: tiene un surco central y dos pares de filas laterales para distribuir la alimentación.

Para más información: Paolo Aliverti, Elettronica per maker – Guida completa, Edi-zioni LSWR.

pinModeEl aspecto «mágico» de Arduino12 es la posibilidad de modificar el comportamiento de un pin directa y simplemente con una instrucción de software. Los pines digitales 12 El hecho de poder modificar la destinación, o mapeados, de un pin a vuestro gusto no es exclusivo

de Arduino, sino de todos los microcontroladores modernos. Algunos circuitos integrados (de-nominados FGPA) pueden modificar las conexiones internamente como si fueran breadboard.

92


pueden funcionar como entradas y salidas. Los podemos utilizar para encender LED, enviar señales al mundo exterior, soltar un botón o recibir informaciones. Antes de utilizar un pin tenéis que declarar qué tipo de comportamiento asumirá: ¿será una entrada o una salida? Esta operación solo la debemos hacer una vez, cuando la pla-ca se enciende y el ATmega328 empieza a leer el sketch. El comando que se debe utilizar es:

pinMode( numero_pin, dirección );

pinMode es una función en la cual debéis pasar dos parámetros:• el número de pin que queréis configurar (para Arduino, van del 0 al 13);• la dirección o el comportamiento del pin, utilizando las “palabras clave” (que,

en realidad, son variables “constantes”) INPUT o OUTPUT.

Para utilizar el pin 11 como salida, en el bloque setup escribid:


Figura 5.6 - Arduino Uno tiene 14 pines digitales que pueden comportarse como entradas o salidas.

Para utilizar el pin como entrada, escribid:

void setup() pinMode(11, INPUT);

93


En el Capítulo 2 he descrito de forma detallada la placa Arduino Uno, listando incluso una serie de entradas especiales, destinadas a la lectura de señales analógicas. Estos pines están marcados con las siglas de A0 a A5. En breve veréis cómo utilizar estas entradas, las cuales no deben ser configuradas con pinMode.Si necesitáis muchos canales digitales, probablemente os convenga más utilizar un Arduino Mega, que no presenta grandes diferencias respecto a un simple Arduino, a no ser porque presenta un mayor número de pines, puertos y funciones. Todos los pi-nes están numerados, por lo que cuando vayáis a utilizar uno comprobad su “nombre” sobre la placa y configuradlo con pinMode.

Configurad el pin 32 de Arduino Mega escribiendo:


void loop() //el resto de instrucciones

Figura 5.7 - Arduino Mega tiene 54 pines de entrada/salida digitales.

No os olvidéis de declarar los pines en el setup. Si no lo hacéis correctamente o si os olvidáis de ello, podréis observar comportamientos extraños e inexplicables. Por ejemplo, si conectáis un LED a un pin y os olvidáis de configurarlo como OUTPUT, el LED no se encenderá correctamente. En circuitos más complejos podríais observar errores generales e inexplicables.

94


¿Cuántas veces se puede utilizar Arduino?

La memoria flash de Arduino tiene un número de escrituras limitado. Durante su carga, los sketch se copian en esta área de memoria que mantiene las informacio-nes incluso cuando Arduino se encuentra apagado. La memoria flash es similar a una memoria USB y puede ser escrita un número limitado de veces. Esto puede parecer una grave limitación, aunque el número real de ciclos de cancelación y escritura de la memoria flash es 10.000.No existen límites en las operaciones de lectura.

delayLa instrucción delay introduce una pausa en el flujo de ejecución de las instrucciones. Cuando Arduino encuentra este comando, se pone en pausa, es decir, se bloquea du-rante el tiempo especificado por la instrucción.

delay ( duración_de_la_pausa );

La instrucción delay acepta, por tanto, un único parámetro de tipo long (sin signo) que corresponde a la pausa deseada, expresada en milisegundos. Puede parecer exage-rado utilizar tal precisión, pero Arduino es capaz de desarrollar 16 millones de ope-raciones por segundo y, por tanto, de poder trabajar tranquilamente con tiempos de microsegundos. Para introducir una pausa de un segundo, debéis escribir:

delay(1000);

Un segundo es igual a 1000 milisegundos. Para obtener pausas muy largas, además de las decenas de segundos, es preferible utilizar otros métodos que evitan el bloqueo del microcontrolador durante demasiado tiempo.

Los LED

El LED es un componente electrónico que puede emitir luz: una especie de lámpa-ra. Tiene la particularidad de generar la luz de forma muy eficiente, consumiendo poca corriente. Las lámparas incandescentes comunes generan la luz sobreca-lentando un sutil hilo metálico que pasa a ser incandescente y emite luz y calor, consumiendo mucha energía (la mayor parte de la cual acaba en calor).

95


Los LED utilizan un proceso físico distinto en el cual un electrón libera energía que se transforma en fotones, es decir, en partículas de luz. Este proceso tiene un alto rendimiento y no produce mucho calor. Los LED tienen también una particu-laridad: pueden ser atravesados por la corriente eléctrica en un único sentido. Su nombre es, en realidad, una sigla que significa Diodo Emisor de Luz.Para encenderlos correctamente, es preciso proporcionarles una tensión y una corriente adecuadas. La tensión depende del color del LED y varía entre 1,8 y 3,5 V.

Tabla 5.1 - Relación entre el color del LED y la tensión de alimentación.

Color Tensión (V)

rojo 1,8amarillo 1,9

verde 2,0blanco 3,0

azul 3,5

La corriente puede variar de 10 a 15 miliamperios.Los LED están dotados de polaridad y, por tanto, tienen un terminal positivo (ánodo) y un términal negativo (cátodo). Los terminales se reconocen observando los LEDs en transparencia. El terminal negativo se reconoce porque:

• es el más corto de los dos;• el borde del LED presenta un bisel en el lado del cátodo;• el cátodo, dentro de la tapa del LED, tiene la forma de una especie de palo

de golf.

El símbolo eléctrico del LED es una especie de flecha que recuerda el sentido en que se desplaza la corriente.

Figura 5.8 - Un LED con el ánodo y el cátodo señala-dos. Junto al LED se encuentra representado su símbolo eléctrico.

96


digitalWritePara activar una salida digital se utiliza el comando digitalWrite indicando el número del pin y el estado que queremos asignarle: alto o bajo (HIGH o LOW).

digitalWrite( numero_del_pin, estado );

Un pin utilizado como salida digital puede asumir solo dos valores, correspondientes a “encendido” y “apagado”, es decir, 5 o 0 V. Cuando se encuentra configurado de este modo, también puede proporcionar una corriente en salida. Un pin configurado como entrada puede absorber corriente. Cuando la corriente que atraviesa el pin es excesi-va, se corre el riesgo de dañarlo irreparablemente. Con Arduino, el límite de corriente es de unos diez miliamperios, motivo por el cual no es posible conectar directamente un relé o un motor, puesto que requieren centenares de miliamperios, sino que se de-ben utilizar transistores o MOSFET de control.Podéis «encender» o «apagar» todos los pines que van del número 0 al 1313. Para com-probar enseguida el comportamiento de digitalWrite, tratad de encender el LED en el pin 13 (que se encuentra integrado en la placa).

Para encenderlo, abrid un nuevo sketch y escribid:


void loop() digitalWrite (13, HIGH);

13 Si utilizáis Arduino Uno, que tiene 14 pines digitales.

Figura 5.9 - El LED integrado en la placa Arduino está conectado al pin 13.

97


En el setup del sketch, habéis configurado el pin 13 como salida. En el loop lo encende-réis configurando el estado HIGH con digitalWrite. Cargad el sketch pulsando en Verify y después en Upload: veréis como el LED L se enciende y se mantiene encendido. Para apagarlo, modificad el sketch cambiando los parámetros de la instrucción digitalWri-te:

digitalWrite (13, LOW);

Para apagar el LED, la salida debe fijarse en el valor LOW. En estos sketch, la instrucción digitalWrite está configurada en la sección loop. Podéis volver a escribirlos mejor:

void setup() pinMode(13, OUTPUT); digitalWrite (13, HIGH);

void loop()

Las instrucciones en el bloque loop se repiten contínuamente, mientras que no es nece-sario repetir digitalWrite una vez que ha sido modificado el estado de la salida. Por eso podéis poner los dos comandos en el bloque setup y dejar el loop completamente vacío.Los pines digitales mantendrán su estado hasta que sean modificados por un nuevo comando.

LED parpadeante montado sobre una breadboardOs propongo un sencillo ejercicio para hacer parpadear un LED colocado sobre una breadboard. Debéis crear un circuito utilizando Arduino, un LED y una resistencia. La resistencia sirve para limitar la corriente que sale del microcontrolador y alimentar co-rrectamente el LED sin dañar Arduino. Con frecuencia, hay ejemplos que muestran un LED insertado directamente en los pines de Arduino, sin utilizar una resistencia: podéis conectar un LED de esta manera solo si colocáis el ánodo en el pin 13 y el cátodo, en el pin GND (situado justo al lado). Esto es posible porque el pin 13 está conectado al LED L de la placa mediante una resistencia y, por tanto, no corréis el riesgo de dañar Arduino. En cualquier otro caso, tendréis que hacer un sencillo cálculo para determinar la resisten-cia que debéis conectar en serie al LED. Imaginad que tenéis un LED verde que necesita una tensión de alimentación de 2 V y una corriente de 10 miliamperios. Pero los pines de Arduino, cuando están configurados como salida y colocados en nivel alto, producen 5 V.Imaginad que sustituís el pin que utilizaréis para encender el LED con una batería de 5 V: esta estará conectada a la resistencia y, por tanto, al LED (el orden no importa porque la corriente no se comporta como el agua que corre por una tubería) (véase la Figura 5.10).

98


Escribid una ecuación con la batería en un lado y en el otro, la resistencia con el LED:

5 V = VLED + RI

Resolviendo esta fórmula en R:

RI = 5 V - VLED

R = (5 V - VLED) / I

Sustituid VLED por 2 V y I por 10 miliamperios (0,010 amperios):

R = (5 V - 2 V) / 0,010 A = 3 V / 0,010 A = 300 Ω

La resistencia que debemos utilizar tiene un valor de 300 ohms, que desafortunada-mente no se encuentra en tiendas. Tendréis que contentaros con una resistencia de 270 o 330 ohms.Prosigamos con el ejercicio. Conseguid todo lo que necesitáis: el LED, la resistencia, la breadboard y cables (o jumpers) para las conexiones.Esto es lo que debéis hacer:

• aseguraos de que Arduino se encuentra conectado al ordenador;• iniciad el IDE de Arduino;

Figura 5.10 - LED conectado sin resistencia en los pines 13 y GND.

99


• copiad el sketch que podéis ver a continuación, el cual hará parpadear el LED en el pin 11;


void loop() digitalWrite (11, HIGH); delay(1000); digitalWrite (11, LOW); delay(1000);

• después de desconectar Arduino del ordenador, construid el circuito que se muestra en la Figura 5.11;

• conectad Arduino al ordenador mediante el cable USB;• cargad el sketch pulsando en Verify y después, en Upload;• después de algunos instantes, cuando el proceso de carga haya terminado, el

LED empezará a parpadear.

Descripción del sketchEn el setup, pinMode configura el pin 11 como salida. La primera operación que se en-cuentra en el loop es digitalWrite(11, HIGH), que enciende el LED. Inmediatamente después, la instrucción delay impone una pausa de un segundo: el LED permanecerá encendido durante este tiempo. Cuando la pausa termine, digitalWrite(11, LOW) apaga el LED y un nuevo delay impone una pausa de un segundo. Al terminar esta pausa, las cuatro instrucciones se repiten: el LED parpadeará con intervalos de un segundo.

Descripción del circuitoEn una breadboard, insertad un LED y una resistencia de 330 ohms. Conectad el pin 11 de Arduino al ánodo del LED y un terminal del resistor, al pin GND, como se muestra en la Figura 5.12. No conectéis directamente a los pines de Arduino dispositivos ni

Figura 5.11 - Esquema eléctrico del circuito con el LED y Arduino.

100


componentes electrónicos que necesitan potencias mayores a los 40/50 miliampe-rios. Los dispositivos que hay que evitar son todos aquellos que incluyen bobinas o arrolamientos, como motores eléctricos, relés e imanes y dispositivos que producen calor.

Figura 5.12 - Composición del circuito eléctrico con Arduino, una resistencia y un LED en el pin 11.

Los seis pines secretos de Arduino

Arduino Uno tiene, en realidad, 20 pines digitales. Lo habéis oído bien: 20, no 14, como aparece impreso en la placa. Los pines «secretos» no son nada más que las entradas analógicas marcadas con las siglas de A0 a A5. Los pines analógicos corresponden a los números 14, 15, 16, 17, 18 y 19. Cuando utilicéis uno de estos pines como digitales, no podéis usarlo como entrada analógica. Para configurar los pines, sencillamente tenéis que declarar su uso con pinMode.Así es cómo podéis hacer parpaderar un LED en el pin A0:

• insertad un LED y una resistencia de 270 ohms en una breadboard (véase la Figura 5.13);

Figura 5.13 - Si lo necesitáis, podéis configurar las entradas analógicas como puertos digitales.

101


• conectad el ánodo (+) del LED al pin A0;• conectad el terminal “libre” de la resistencia a GND;• cargad el siguiente sketch:

void setup() pinMode(14, OUTPUT); //el pin A0 void loop() digitalWrite(14, HIGH); delay(1000); digitalWrite(14, LOW); delay(1000);

digitalReadPara leer el estado de un pin digital utilizado como entrada se utiliza digitalRead, indi-cando como parámetro el número de la línea que hay que interpretar:

int digitalRead( número_del_pin );

La función devolverá un valor numérico de tipo entero (int) que podrá valer solo HIGH o LOW. Habitualmente, el resultado de la función se guarda en una variable de tipo int:

int tecla1 = digitalRead( 7 );

Para utilizar un pin como entrada digital, no debéis olvidaros de declararlo como tal en la sección setup del sketch. Utilizad pinMode para configurar el pin múmero 7:

void setup() pinMode(7, INPUT);

El caso más simple de uso de digitalRead es para detectar la pulsación de un botón. El pin configurado como entrada digital puede detectar si la tensión aplicada es igual a 0 o 5 V. Es necesario construir un pequeño circuito con un botón o una breadboard. El esquema eléctrico se encuentra ilustrado en la Figura 5.14. Debéis conseguir un botón del tipo normalmente abierto, una resistencia de 10.000 ohms, un LED verde y una resistencia de 330 ohms, además de una breadboard y al-gunos jumpers pra realizar las conexiones. La Figura 5.15 ilustra la disposición de los componentes en la breadboard.

102


Figura 5.15 - Arduino conectado a un botón en el pin 7 y a un LED en el pin 11.

El botón tiene dos terminales14: uno, conectado a tierra mediante la resistencia de 10 kiloohms y también al pin 7; el otro, conectado a los 5 V de corriente. Así, la entrada de Arduino está conectada de forma estable a 0 V mediante la resistencia. No circula corriente y, por tanto, el pin 7 puede considerarse de nivel bajo. Cuando pulsamos el botón, conectamos los 5 V a la resistencia y, por tanto, al pin 7. Si la resistencia no estuviera, al pulsar el botón uniríamos directamente los 5 V con la tierra, ¡creando un cortocircuito!El sketch no es muy complicado:

void setup() pinMode(7, INPUT); pinMode(11, OUTPUT);

void loop() int tecla1 = digitalRead(7);

14 En realidad, este tipo de botón tiene cuatro terminales por razones de estabilidad mecánica, que están conectados por parejas.

Figura 5.14 - Esquema eléctrico de conexión de un botón a Arduino.

103


if (tecla1 == HIGH) digitalWrite (11, HIGH); delay(1000); digitalWrite (11, LOW);

En el setup podemos ver la configuración de los pines: el pin 7 está configurado como entrada y el pin 11, como salida. En la sección loop, el programa lee el estado del pin 7 con digitalRead y lo guarda en la variable de tipo int denominada tecla1. La función di-gitalRead requiere un único parámetro, el número del pin que debe leer, y proporciona el estado del pin, que puede ser HIGH o LOW. La primera línea de la sección loop lee el estado del pin y lo guarda en la variable tecla1. El contenido de la variable está contro-lado por la instrucción if y, si este es igual a HIGH porque alguien ha pulsado el botón, se ejecutan las instrucciones encerradas entre las dos llaves: digitalWrite enciende el pin 11 y, seguidamente, se produce una pausa de un segundo. Tras esta pausa, el programa sale del bloqueo if y se encuentra con la instrucción digitalWrite que apaga el LED. Si nadie pulsa el botón, la lectura del pin devuelve LOW y Arduino no ejecuta las instrucciones de if, pasando directamente a la última digitalWrite que apaga el LED.Quizás os habrá surgido la duda de cómo conectar el botón a Arduino. No lo conectéis directamente al pin. Un error común consiste en conectar un terminal del botón a los 5 V y el otro terminal, a Arduino, para que al pulsar el botón se apliquen directamente 5 V al microcontrolador. Por desgracia no ocurre así: el pin de Arduino, cuando el botón se encuentra pulsado, no está conectado a nada y puede asumir estados inesperados15.

analogWriteLa función analogWrite produce una señal PWM, es decir, una onda cuadrada cuyo porcentaje de señal de encendido y apagado puede ser modificado libremente. La fun-ción analogWrite requiere dos parámetros: el pin de salida y un número que indica la

15 En ciertos casos, se puede conectar un botón sin utilizar la resistencia externa. Más adelante veremos cómo hacerlo.

Figura 5.16 - En el esquema de la izquierda, el botón está conectado correctamente a Arduino, mientras que el esquema de la derecha muestra una conexión incorrecta.

104


relación entre encendido y apagado. El número no es un porcentaje, sino un valor que va de 0 a 255. No todos los pines de Arduino pueden generar una señal de este tipo: los que están habilitados son los pines 3, 5, 6, 9, 10 y 11. Los reconoceréis porque en la placa, junto al número, se muestra una tilde (~).

analogWrite ( número_del_pin, valor_pwm );

El nombre de esta función induce a confusión, porque no produce una señal analógica, sino una onda cuadrada variable (es decir, una señal PWM).Arduino Uno lee señales analógicas pero no puede producirlas16.De uno de sus 14 pines podréis hacer salir 2,25 V, pero sólo una tensión igual a 0 o 5 V. Sin embargo, aplicando una señal PWM a un LED podréis modular su luminosidad con gran precisión. Cuando el valor del PWM está a 0, el LED está apagado porque la onda cuadrada en salida está siempre «a nivel bajo». Probad con el siguiente sketch:

void setup() pinMode(11, OUTPUT); analogWrite(11, 0);void loop()

Para utilizar el sketch tenéis que sustituir un simple circuito, como se muestra en la figura siguiente. Utilizad un LED que conectaréis al pin 11 de Arduino. Necesitaréis también una breadboard, jumpers y una resistencia de 330 ohms. Cargadlo y... no ocu-rre nada: el LED está apagado.

Figura 5.17 - Conexión de un LED al pin 11 para la prueba con la señal PWM.

Cuando el valor del PWM sea igual a 255, el pin emitirá una señal constante igual a 5 V y el LED se encenderá por completo:

16 Arduino Due y la placa Arduino Zero, en cambio, están dotadas de salidas analógicas.

105



Cargad el sketch y podréis ver que el LED permanece encendido. Ahora intentad mo-dificar el valor insertado en analogWrite, escribiendo un número comprendido entre 0 y 255. Para encender el LED a media potencia escribid, por ejemplo, 127:


El LED ahora parece que se encienda con la mitad de su potencia, pero es una ilusión óptica. En realidad, del pin 11 sale una señal rapidísima que pasa de 0 a 5 V muchas veces en un segundo. Modificando el valor pasado a la función, cambiaréis la relación entre el tiempo en que la señal se encuentra en el estado alto y aquel en que se en-cuentra en el bajo, dando la impresión de que el LED se enciende más o menos.Una señal PWM puede ser utilizada también para controlar la velocidad de un motor eléctrico. No conectéis directamente el motor a Arduino: se necesita un transistor para evitar dañar el microcontrolador.Si utilizar un número del 0 al 255 para ajustar la luminosidad os parece un poco inusual, podéis adoptar la función map, que ejecuta una proporción y remapea los números del 0 a 100 sobre aquellos del 0 al 255.


void loop() int lum = 10; int pwm = map(lum, 0,100, 0,255); analogWrite (11, pwm);

En el sketch podéis ver dos variables de tipo entero denominadas lum y pwm.La función map recibe como parámetro la variable lum, que representa la luminosidad deseada expresada en porcentaje, y la remapea entre 0 y 255. Si lum vale 10, map devol-verá 25,5: pero como debe ser un número entero, obtendremos 25.Cargad el sketch en Arduino y observad el comportamiento del LED. Modificad el valor de lum y observad cómo cambia la luz emitida por el LED.

106


Con Arduino Zero y Arduino Due es posible modificar el número de «pasos» que se pueden utilizar con analogWrite. Arduino Uno puede establecer 256 pasos, que son igual a 8 bits, mientras que en las otras placas es posible aumentar la resolu-ción con:

analogWriteResolution(bits);

En estas placas, el número de bits puede ser ajustado como máximo a 12, pudiendo utilizar por tanto 4096 pasos. Es posible utilizar también valores inferiores de bits.

Serial MonitorNo es fácil saber qué ocurre dentro de Arduino. Si el sketch es sencillo y todo funciona, no hay problema, pero si algo va mal no podemos saber de inmediato qué está sucien-do. Es posible transmitir informaciones a través del puerto serie de Arduino y después leerlas en vuestro PC17. Cuando el puerto serie no se utiliza en la programación del microcontrolador, podéis utilizarlo para intercambiar informaciones que se puedan vi-sualizar en una ventana de vuestro ordenador. Para utilizar el puerto serie de Arduino, es preciso configurarlo en el setup:

void setup() Serial.begin(9600);

La configuración del puerto serie requiere un único parámetro: la velocidad de co-municación, que habitualmente se ajusta a 9600 baudios18. A continuación, podéis escribir en el puerto serie con:

Serial.println("Hello World!");

Este es el sketch completo:

void setup() Serial.begin(9600); Serial.println("Hello World!");

void loop()

17 Solo cuando Arduino y el PC están conectados con un cable USB.18 Un baudio indica el número de símbolos, es decir, grupos de bits, transmitidos por segundo a

través de una línea digital.

107


¿Dónde acaban estos mensajes? Se envían hacia el ordenador y pueden leerse abrien-do el Serial Monitor de Arduino, es decir, una ventana que muestra los mensajes reci-bidos (y que también puede transmitirlos).

Figura 5.18 - Para abrir el Serial Monitor, pulsad el botón en la barra de herramientas de Arduino.

Este es un sketch que, cada segundo, envía un mensaje al PC:


void loop() Serial.println("Hello World!"); delay(1000);

En el setup se configura el puerto serie, indicando su velocidad de transmisión. En la sección loop, la instrucción Serial.println envía un texto al puerto serie y delay ajusta la pausa de un segundo.

108


Cargad el sketch y después abrid el Serial Monitor para recibir el mensaje: observaréis que, cuando se abre el Serial Monitor, Arduino se resetea19.

Figura 5.19 - El Serial Monitor recibe los mensajes enviados por Arduino.

De este modo podéis controlar el valor de una variable o una condicion presente en un sketch y enviarla al Serial Monitor, para saber cómo se está comportando dicho sketch. Probad a cargar el sketch siguiente:

int i = 0;


void loop() Serial.print("i = "); Serial.println(i); delay(1000); i++;

Cargad el sketch en Arduino y abrid el Serial monitor: veréis una secuencia de núme-ros que aumenta a intervalos de un segundo.

19 El Serial Monitor envía una señal «estándar» denominada RTS, que en la placa se encuentra conectada a Reset. Inevitablemente, cada vez que abráis el Serial Monitor, Arduino se reseteará. Podéis evitarlo con un terminal que os permita no enviar la señal de RTS, desactivando el control de flujo de la transmisión de serie.

109


Figura 5.20 - Serial Monitor con la secuencia progresiva de números transmitidos por Arduino.

El sketch utiliza una variable fuera de las secciones loop y setup y que es visible en ambos bloques. En el loop, la instrucción print muestra un texto sin retorno y la ins-trucción siguiente, println, muestra la variable i: a diferencia de print, println añade un carácter de «retorno de carro». La última instrucción del loop incrementa la variable i en una unidad.

analogReadArduino no puede generar señales analógicas, pero puede interpretarlas con la si-guiente función:

int analogRead ( número_puerto_analógico );

analogRead convierte el valor de tensión presente en una de las entradas analógicas dedicadas (los pines de A0 a A5) en un número comprendido entre 0 y 102320. Po-déis conectar cualquier tipo de sensor analógico que produzca una tensión entre 0 y 5 V. Conectad una fotorresistencia a Arduino y leed su valor. La fotorresistencia es un componente especial, sensible a la luz: tiene una resistencia de algún kiloohm que debéis conectar en serie con una resistencia de 10 kiloohms, formando un divisor de voltaje. Conectad el pin A0 al punto central del divisor (véase la Figura 5.21).

20 El valor mínimo de señal que podéis leer es igual a 5 V / 1024, o, lo que es lo mismo, 0,0048 V, es decir aproximadamente 5 mV.

110


Figura 5.22 - Creación del circuito sobre una breadboard.

No es preciso declarar las entradas analógicas.Este es el sketch para controlar la cantidad de luz que alcanza la fotorresistencia:


void loop() int luce = analogRead(A0); Serial.print("nivel luz: "); Serial.println(luz); delay(200);

Figura 5.21 - Esquema eléctrico del circuito para conectar una fotorre-sistencia a Arduino.

111


En el setup se configura solo el puerto serie, porque no es necesario declarar las entra-das analógicas como tales. En el loop el valor identificado por analogRead se conserva en la variable entera luz. El valor de la variable se muestra en el Serial Monitor. Por último, podéis ver una pausa de 200 milisegundos para evitar que Arduino inunde el Serial Monitor con una larga secuencia de datos.Conectad Arduino y cargad el sketch; después abrid el Serial Monitor para leer la se-cuencia de números: tendríais que ver cambiar los valores que hacen sombra a la fotorresistencia (o que la iluminan).Tratad de escribir un sketch para encender un LED solo cuando está oscuro.

Controlar el tiempoLos microcontroladores no son muy potentes, pero pueden ser muy rápidos. Por eso, son capaces de medir el tiempo con una precisión óptima, y también porque en su interior no funciona un sistema operativo, es decir, un software complejo y compuesto por numerosas líneas de código, sino sketch simples e inmediatos. En un microcon-trolador en el cual se ejecuta un sistema operativo, es difícil controlar con precisión los tiempos de ejecución; en cambio, en Arduino podéis trabajar también en micro-segundos. En los ejemplos anteriores habéis aprendido a utilizar delay() para efectuar pausas en la ejecución de los programas. Podéis configurar pausas incluso en micro-segundos:

unsigned long

delayMicroseconds( duración_de_la_pausa );

Podéis indicar la duración de la pausa con un número de tipo unsigned int que va del 0 al 65.535. De hecho, el valor mínimo que podéis utilizar es igual a 3 microsegundos, mientras que el valor máximo aconsejado es 16.383. Las páginas de referencia de Ar-duino aconsejan configurar pausas máximas de algunos miles de microsegundos y para valores superiores utilizar la función delay().Probad de modificar el sketch Blink utilizando delayMicroseconds().Otro método para realizar pausas largas personalizadas es utilizar marcadores tem-porales (timestamp). La idea es realizar una pausa definiendo antes su duración y, después, marcando el tiempo de inicio. Periódicamente, se comprueba la hora actual y se establece si la diferencia con el tiempo inicial es igual a la pausa deseada. Así, se pueden llevar a cabo pausas muy largas y, sobre todo, no se bloquea el microcontrola-dor, el cual mientras tanto puede realizar otras acciones.El algoritmo, o secuencia de operaciones, que se debe desarrollar es el siguiente:

112


• definir la pausa que se desea efectuar. Supongamos que sea de una hora;• controlar el reloj e indicar la hora actual (por ejemplo, las 10:15) en la variable t1;• controlar el reloj, leer la hora actual y calcular la diferencia con la hora guardada

en t1. Son las 10:16, por tanto, 10:16 - 10:15 es igual a un minuto;• comprobar si la diferencia calculada es igual o mayor que la pausa deseada. En

caso afirmativo, se puede finalizar; si no, se regresa al punto anterior.

En Arduino podéis «echar un vistazo al reloj» invocando la función:

unsigned long millis();

Esta devolverá un número de tipo unsigned long igual al número de milisegundos transcurridos desde el momento del encendido. Arduino no es capaz de devolveros la hora y la fecha como si fuera un reloj, y tampoco es capaz de memorizar estas informaciones. Es posible crear circuitos (o shields) dotados de un chip especial que funciona como reloj, con una batería interna, que puede mantener la hora y la fecha incluso cuando Arduino está apagado.Este es el sketch para encender un LED tras un minuto de espera:

long t1 = 0;long pausa = 1*60*1000; //1 minuto expresado en milisegundos

void setup() Serial.begin(9600); pinMode(13, OUTPUT); t1 = millis(); Serial.print("tiempo inicial:"); Serial.println(t1);

void loop() long diferencia = millis() – t1; if (diferencia > pausa) Serial.println("Fin pausa."); digitalWrite(13, HIGH); Serial.print("diferencia:"); Serial.println(diferencia);

En primer lugar tenéis que definir una variable para memorizar el tiempo inicial y otra para indicar la duración de la pausa. En el setup, configurad el pin 13 como salida y preparad el puerto serie para mostrar en la consola; después, llamad a millis() para guardar el tiempo inicial.En el loop, primero se calculará la diferencia entre el tiempo actual y t1; si la diferencia es mayor que el intervalo de tiempo memorizado en la variable pausa, el LED integrado

113


en el pin 13 se encenderá. Si el loop es demasiado rápido, insertad un delay de unos diez (o cien) milisegundos.Podéis medir el número de microsegundos desde el encendido de la placa con:

unsigned long micros();

Y ahora, ¡un poco de música!Producir sonidos con Arduino no es difícil, aunque no es un gran músico: puede generar solo cuatro ondas cuadradas que producen sonidos bastante fríos y metálicos. Podéis utilizar analogWrite para generar una señal, o bien confiar en una función específica:

void tone(pin, nota);

que sonará hasta que declaréis:

void noTone();

De otro modo, podéis indicar la duración de la nota con un tercer parámetro:

void tone(pin, nota, duración);

La duración se indica en milisegundos; tone puede ser utilizada en cualquier pin y ge-nera una onda cuadrada con una relación encendido/apagado (duty cycle) del 50%. Desafortunadamente no podéis hacer sonar más de una nota a la vez. Para crear soni-dos más elaborados, podéis utilizar chips (o shields) específicos.Las notas se indican precisando la frecuencia, acción que podría no ser demasiado ágil. Para facilitar el proceso, podéis definir constantes correspondientes a las notas. En Internet podéis encontrar archivos para incluir en el proyecto que os proporcionan todas las notas listas para usar.

Tabla 5.2 - Frecuencias de las notas para usar con tone().

Nota Nota (anglosajón) Frecuencia (Hz)

do C 261re D 294mi E 329fa F 349sol G 392la A 440si B 493do C 523

114


Intentad conectar un buzzer piezoeléctrico al pin 12 utilizando una resistencia de 100 ohms (véase la Figura 5.23) y, después, cargad el siguiente sketch a Arduino:

#define F3 174.61#define Gb3 185.00#define G3 196.00#define Ab3 207.65#define LA3 220.00#define Bb3 233.08#define B3 246.94#define C4 261.63#define Db4 277.18#define D4 293.66#define Eb4 311.13#define E4 329.63#define F4 349.23#define Gb4 369.99#define G4 392.00#define Ab4 415.30#define LA4 440.00

#define Q 500 //tono#define H 2*Q //mediotono#define E Q/2 //octava#define S Q/4 //decimosexto#define W 4*Q //entero


void loop() tone(8,LA3,Q); delay(1+Q); tone(8,LA3,Q); delay(1+Q); tone(8,LA3,Q); delay(1+Q); tone(8,F3,E+S); delay(1+E+S); tone(8,C4,S); delay(1+S); tone(8,LA3,Q); delay(1+Q); tone(8,F3,E+S); delay(1+E+S); tone(8,C4,S); delay(1+S); tone(8,LA3,H); delay(1+H);

115


Figura 5.23 - Conectad un buzzer piezoeléctrico al pin 12 de Arduino utilizando una resistencia de 100 ohms.

En este sketch se observa la palabra clave define que podéis utilizar para definir cons-tantes sin consumir memoria, porque antes del Verify el compilador de Arduino susti-tuirá todas las coincidencias de la constante con el valor asociado:

#define nombre valor

Por ejemplo, podéis definir las notas o el nombre de un pin:

#define led 13

void setup() pinMode(led, OUTPUT);

En este fragmento de sketch, en lugar de utilizar el número del pin, se ha utilizado una constante denominada led.Volviendo a la función tone, podéis encontrar ejemplos muy interesantes en la co-lección de Arduino. Abrid el sketch File > Examples > Digital > ToneMelody para cargar un interesante ejemplo «musical». Este sketch tiene la particularidad de es-

116


tar formado por dos archivos, cargados cada uno en una pestaña determinada. El archivo principal se llama toneMelody, el archivo adicional lo podéis encontrar en el segundo panel, pitches.h.

Figura 5.24 - Un sketch compuesto por más de un archivo.

¿Cómo podéis añadir más archivos a vuestro sketch original? La operación es muy sencilla. Seguid estas instrucciones:

• creáis un nuevo sketch (File > New);• pulsáis sobre el pequeño botón en forma de triángulo invertido situado en la

parte derecha de la barra de herramientas;• en el menú contextual, pulsáis sobre New Tab;• en la parte inferior de la ventana, aparecerá una banda de color amarillo. Escri-

bís el nombre que queráis asignar al nuevo archivo, por ejemplo, “constantes.h”;• aparecerá un nuevo panel con el nombre “costantes.h”;

117


• si el panel no está seleccionado, hacéis clic sobre el título e insertáis vuestro código. Probad a insertar una simple constante (también podéis incluir en el archivo variables y funciones);

#define led 13

• pulsáis sobre el primer panel para abrir el archivo principal. Para conectar el archivo, debéis añadir al inicio la sentencia indicada a continuación;

#include "costantes.h"

• Pulsáis en Verify y compiláis el archivo.

Medir la longitud de una pulsaciónAhora que utilizáis con soltura las funciones para medir el tiempo, probablemente no tendréis ninguna dificultad para escribir un sketch que calcula durante cuánto tiempo está pulsado un botón (o, simplemente, cuánto dura una pulsación). Sin mucho es-fuerzo, Arduino os ofrece una función que escucha un pin determinado y devuelve la duración de los impulsos que se presentan. La medida se proporciona en microsegun-dos. La función se denomina:

unsigned long pulseIn(pin, value);

El primer parámetro indica el pin que se debe controlar. El parámetro value puede ser configurado igual que HIGH para que la medida de la pulsación empiece cuanto este pasa del estado bajo al alto (flanco ascendente). Si value es igual a LOW, la medición empezará en el frente descendiente de la señal. Puede ser que la medida no sea muy precisa, sobre todo con pulsaciones muy largas. Debéis tener en cuenta que en el sitio de Arduino se declara que es posible detectar pulsaciones de 10 microsegundos a casi 3 minutos.La función acepta un tercer parámetro denominado timeout (de tipo unsigned long):

unsigned long pulseIn(pin, value, timeout);

timeout indica el tiempo máximo (en microsegundos) durante el cual Arduino perma-necerá a la espera de una pulsación. Pasado el tiempo límite sin que haya ocurrido nada, la función (que se bloquea) devolverá 0. Si no se proporciona ningún valor, se utiliza un tiempo límite de un segundo.Reconstruid el circuito de la Figura 5.15 conectando un botón y un LED a Arduino, aun-que el LED en este caso no será utilizado.

118


void setup() pinMode(7, INPUT); Serial.begin(9600);

void loop() unsigned long durata = pulseIn(7, HIGH); if (durata > 0) Serial.print("duración pulsación: "); Serial.print(duración / 1000); Serial.println(" ms.");

En el setup debéis configurar el pin7 como entrada y preparar el puerto serie. En la sec-ción loop, pulseIn eschucha el pin 7. Si tras un segundo llega una pulsación, empieza su medición y la guarda en la variable duración, si no, devuelve el valor 0. Un test muestra en la consola la duración de la pulsación del botón solo si esta es mayor que 0. Cargad el sketch y abrid la consola de Arduino, después pulsad el botón en la breadbord y leed el valor que aparece. Si pulsáis el botón durante más de un segundo, no obtendréis ningún resultado porque empezará el timeout.

Funciones matemáticasPara escribir vuestros sketch, tendréis que utilizar en algún momento un poco de ma-temáticas. En ocasiones se utilizan funciones para trabajar con ángulos u otros nú-meros de manera “especial”. A continuación, os muestro una breve panorámica de algunas funciones que os podrían ser útiles.

min(a, b);

La función min devuelve el menor de los dos números proporcionados como argumen-to y funciona con cualquier tipo de número y de variable. En el manual de referencia de Arduino, se recomienda utilizar como parámetros solo valores numéricos o variables, así como no utilizar funciones, porque podríais obtener resultados imprevistos.En el siguiente caso:

int v = 20;int r = min (10, v);

La variable r asumirá el valor 10.

max(a, b);

La función max devuelve el mayor de los dos números proporcionados como argumen-to y funciona con cualquier tipo de número o variable. En el manual de referencia de

119


Arduino, se recomienda utilizar como parámetros solo valores numéricos o variables, así como no utilizar funciones, porque podríais obtener resultados imprevistos.

abs(x);

Esta función devuelve siempre un número positivo. Si x vale -10, obtendréis 10. abs significa “absoluto”.

constrain(n, a, b);

La función constrain resulta ideal para contener una variable dentro de un valor míni-mo y de un valor máximo. La variable n podría recibir su valor de un sensor analógico. Asignad a a el valor mínimo admisible y a b, el valor máximo.

int n = analogRead(A0);int r = constrain(n, 50, 200);

Si el valor interpretado por el sensor y guardado en la variable n se mantiene entre 50 y 200, la función devolverá el mismo valor. Si n supera 200, entonces el resultado será 200. Si n es inferior a 50, la función devolverá igualmente el valor mínimo 50.

map(n, a, b, c, d);

Esta función se utiliza para calcular proporciones: recibe un valor en entrada n que de-bería estar entre a y b y lo recalcula, realizando una proporción, entre c y d. A menudo se utiliza para transformar en porcentaje un valor leído por un sensor analógico (que va de 0 a 1023).

int n = analogRead(A0); //la lectura es entre 0 y 1023int porcentaje = map(n, 0, 1023, 0, 100);

La variable procedente del sensor porcentaje que puede asumir todos los valores de 0 a 1023 se “mapea” entre 0 y 100.Podéis utilizar map también para invertir un valor:

int parámetro = map(n, 0, 255, 255, 0);

Los parámetros proporcionados a map también pueden ser números negativos, pero deben ser siempre números enteros (o long).

pow(base, exponente);

120


Para calcular las potencias de un número, se utiliza pow, indicando la base y el expo-nente que se debe aplicar. Los parámetros son números de tipo float y el resultado es un double.

sqrt(número);

No podía faltar aquí una función para calcular la raíz cuadrada de un número. El pa-rámetro es un número en cualquier formato y el resultado es siempre de tipo double.

sin(alfa);cos(alfa);tan(alfa);

Para trabajar con ángulos, se utiliza sin, cos y tan. El ángulo proporcionado debe ser en radianes y de tipo double. El resultado de las funciones es un número de tipo double. Es-tamos acostumbrados a manejar ángulos que van de 0° a 360°: un ángulo expresado en radianes, en cambio, va de 0 a 2π. Podéis convertir los ángulos utilizando esta proporción:

360° : ángulo = 2π : ángulo_radianes

El ángulo en radianes surge de:

ángulo_radianes = (2π · ángulo) / 360

A veces, también nos puede resultar útil generar números aleatorios. Para ello, utilizad:

random(max);

Podréis obtener un número aleatorio comprendido entre 0 y el valor máximo indicado menos 1 (max - 1). En cambio, si queréis limitar el intervalo a partir del cual se selec-cionan los números aleatorios se utiliza:

random(min, max);

Generar números aleatorios para un ordenador es bastante complejo: por este moti-vo, para obtener secuencias más imprevisibles, es mejor inicializar el mecanismo de generación de números aleatorios utilizando la función randomSeed. Para obtener una buena inicialización, pasad a la función una lectura tomada por una entrada analógica «desconectada», donde seguramente habrá ruido.

void setup() Serial.begin(9600); randomSeed(analogRead(A0)); long n = random(100); Serial.println(n);

121


Funciones para caracteresLas funciones para caracteres permiten analizar cadenas y secuencias de caracteres, re-conocer el tipo al que pertenecen y, por tanto, actuar de manera oportuna. Existe una do-cena de funciones que pueden analizar un carácter cada vez y devolver un valor booleano (verdadero o falso) para indicar el resultado. Esta es la lista de las funciones disponibles:

boolean ret = isAlphaNumeric(carácter); boolean ret = isAlpha(carácter);boolean ret = isAscii(carácter);boolean ret = isWhitespace(carácter);boolean ret = isControl(carácter);boolean ret = isDigit(carácter);boolean ret = isGraph(carácter);boolean ret = isLowerCase(carácter);boolean ret = isPrintable(carácter);boolean ret = isPunct(carácter);boolean ret = isSpace(carácter);boolean ret = isUpperCase(carácter);boolean ret = isHexadecimalDigit(carácter);

En la dirección https://www.arduino.cc/en/Reference/CharacterAnalysis encontraréis un interesante sketch que recibe caracteres de la consola de Arduino, los analiza con todas las funciones posibles y devuelve una lista de resultados. Así, podéis comprobar cómo se comportan los distintos caracteres cuando se someten a funciones de análisis.

Funciones para manipular bits y bytesTrabajando con microcontroladores, en alguna ocasión es posible que tengáis que tra-bajar con bits y bytes. Afortunadamente, Arduino cuenta con muchas funciones de alto nivel que limitan muchísimo el uso de bits y de bytes. Para configurar los puertos de entrada o de salida o el estado de un pin, podríais trabajar directamente en los registros del microcontrolador: operación innecesariamente complicada y bastante críptica. Para ocasiones especiales, aquí tenéis algunas funciones que simplificarán las operaciones.Las funciones lowByte y highByte extraen el byte más alto o más bajo de un número o de una variable.Antes de continuar, sería mejor realizar alguna aclaración acerca de bit y byte: un bit es una pequeña unidad de memoria que puede asumir solo dos estados: “0” o “1”. El conjunto de 8 bits se denomina byte.Contar en bits no es muy difícil, se empieza desde 0 y, agregando una unidad, obte-nemos 1. Añadiendo una nueva unidad tendremos 10 y no 2: esto es así porque los números que utilizamos habitualmente utilizan las cifras del 0 al 9 y, cuando contando llegamos a 9, reiniciamos las unidades, añadimos una decena y tenemos un 10. Esta sería una cuenta binaria:

122


• 0 vale 0;• 1 vale 1;• 10 vale 2;• 11 vale 3;• 100 vale 4;• 101 vale 5;• 110 vale 6, etc.

Un número formado por 8 bits forma un byte, que, por tanto, puede asumir todos los valores desde 00000000 hasta 11111111, es decir, de 0 a 255. Para evitar tener que escribir todos estos “1” y “0”, a menudo se usa la notación hexa-decimal: otro sistema de numeración que utiliza 16 símbolos en lugar de las populares diez cifras del 0 al 9. En el sistema hexadecimal las cifras posibles son: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Los símbolos de la A a la F valen 10, 11, 12, 13, 14 y 15. Contando en hexadecimal, una vez llegamos a la F, se continúa reiniciando las unidades y aña-diendo una decena: después de la F viene “10”, que, sin embargo, valdrá 16. Todos los símbolos hexadecimales pueden ser escritos con 4 bits, por lo que:

• 0 corresponderá a 0000;• 1 corresponderá a 0001;• 2 corresponderá a 0010;• 3 corresponderá a 0011;• hasta llegar a F, que será igual a 1111.

Puesto que un byte está formado por 8 bits, podéis indicarlo con dos cifras hexadeci-males que son exactamente igual que 8 bits:

• 01 en hexadecimal es igual a 0000 0001, es decir, a 1 en decimal;• 0A en hexadecimal es igual a 0000 1010, es decir, a 10 en decimal;• 0F en hexadecimal es igual a 0000 1111, es decir, a 15 en decimal;• 10 en hexadecimal es igual a 0001 0000, es decir, a 16 en decimal;• A0 en hexadecimal es igual a 1010 0000, es decir, a 160 en decimal;• FF en hexadecimal es igual a 1111 1111, es decir, a 255 en decimal.

Un número entero en Arduino está formado por 4 bytes. Por ejemplo, el número 6660 está formado por 4 bytes 00001A04, es decir, por los bits 0000 0000 0000 0000 0001 1010 0000 0100. El byte “alto” de este número es igual a los primeros 4 bits empezando por la izquierda, 0000 0000, y, por tanto, 0 (en decimal). Podéis extraer el byte más alto utilizando la función:

byte val = highByte(n);

123


En cambio, el byte más bajo es 0000 0100, que vale 8 (decimal) y podéis extraer con:

byte val = lowByte(n);

Arduino también proporciona funciones para leer los bits individuales de un número: Mediante:

byte val = bitRead(número, bit_para_leer);

podréis leer el bit situado en la posición n de la variable x. La posición se lee a partir del bit menos importante, es decir, el situado a la derecha de la secuencia de bits. El valor de n empieza en el 0.Para configurar un bit individual, en cambio, utilizad:

bitWrite(número, bit_para_leer, bit);

La posición del bit dentro del número está indicado por bit_para_leer. El valor que hay que configurar está especificado por bit, que puede valer 1 o 0.La función:

bitSet(número, bit_para_configurar);

es equivalente a bitWrite, con la diferencia que ajusta el bit indicado a 1.En cambio, la función:

bitClear(numero, bit_para_reiniciar);

resetea el bit indicado, llevándolo a 0.Aquí tenéis un sketch como resumen para hacer pruebas con estas funciones.


int n = 42258; //A512 byte lo = lowByte(n); Serial.println(lo); //muestra 18... es decir 12H byte hi = highByte(n); Serial.println(hi); //muestra 165 es decir A5H

for (int i = 15; i >= 0; i = i - 1) byte b = bitRead(n, i); Serial.print(b); //muestra 1010010100010010

void loop()

124


Copiad el sketch y cargadlo en Arduino. Para este ejemplo no se necesita ningún hard-ware. Tras haber cargado el sketch, abrid el Serial Monitor para observar los resulta-dos.Por otro lado, la función bit calcula el valor de un bit y es un atajo para ayudaros a transformar un bit en un valor decimal. La función equivale a multiplicar el número “2” tantas veces como indica el parámetro proporcionado.

int val = bit(n);

bit(0) es igual a 1, bit(1) vale 2, bit(3) vale 8, es decir, es lo mismo que ejecutar la siguiente multiplicación: 2 × 2 × 2, o bien que 23. Con esta función podéis convertir un número binario en formato decimal. Si tenéis el número 1010, la conversión será del modo siguiente: 1 × 23 + 0 × 22 + 1 × 21 + 0 × 20 = 1 × 8 + 0 + 1 × 2 + 0 = 10En un sketch escribid:

int val = 1 * bit(3) + 0 * bit(2) + 1 * bit(1) + 0 * bit(0);

Conversiones de tipoAl escribir los sketch, de vez en cuando tendréis que modificar el tipo de algunas va-riables.En cuanto a los tipos de variables, el lenguaje C es bastante meticuloso. Sin embargo, muchos lenguajes no hacen diferencias respecto a ello, hasta el punto que algunos no requieren ni que se especifique el tipo de dato que memorizaréis: una variable es una posición de memoria y podéis incluir en ella cuanto deseéis. En cambio, en C es preciso decir exactamente qué tipo de dato vais a memorizar, porque cada uno tiene dimensiones distintas y puede ser tratado de manera distinta. Por ejemplo, un byte o un carácter ocupan solo 8 bits, los números enteros, 4 bytes, etc. Un carácter se mos-trará con una letra, mientras que un byte será tratado como un número.Arduino dispone de algunas funciones para ejecutar conversiones entre tipos de datos diferentes. Tened en cuenta que habitualmente no existe ningún problema en pasar de un dato más pequeño a uno más grande (por ejemplo, de byte a int), mientras que en el caso contrario se deberán sacrificar ciertas informaciones. Por ejemplo, pasando de int a byte, o bien de un número con coma a un número entero.Las funciones contenidas en Arduino son:

• char(x) convierte un valor en un carácter char;• byte(x);• int(x);• word(x);

125


• long(x);• float(x).

Al combinar varios números en una operación matemática, debéis aseguraros que los números sean todos compatibles entre ellos, si no podríais conseguir resultados un poco extraños. Recordad que podéis aplicar una conversión de tipo anteponiendo al número o a la variable el tipo deseado, entre paréntesis:

(int)ch;

Este texto convierte el carácter ch en un entero.

sizeofEl operador sizeof devuelve las dimensiones en bytes de una variable. Es útil cuando se trabaja con matrices o con cadenas de las cuales se desconoce previamente la longitud.

char texto[] = "¿cuántos caracteres?";int n = sizeof(texto);

La variable n contendrá el valor 17.

127

En este capítulo aprenderéis mucho más sobre Arduino

afrontando problemas prácticos de distintas dificulta-

des. Aprenderéis a resolver casos comunes con una se-

rie de ejemplos desde el punto de vista del hardware y el

software. La electrónica, así como la programación, está

llena de patrones, es decir, configuraciones comunes, repe-

tibles y adaptables para resolver los problemas que surgen.

Conectar un LEDEn el Capítulo 5 habéis aprendido a conectar un LED a Arduino. Cada LED debe estar acompañado por una resistencia adaptada a su tensión de alimentación y a la corrien-te de funcionamiento, la cual normalmente es de 10 o 15 miliamperios. Para no tener problemas, recordad siempre:

• evitar conectar directamente los LED a los pines de Arduino (utilizad siempre una resistencia);

• controlar la polaridad del LED (conectad su cátodo a GND y el ánodo, a un pin de salida);

• configurar como OUTPUT el pin al cual conectaréis el LED (utilizad pinMode);• encender y apagar el LED con digitalWrite.

Quizás no todos saben que se puede conectar un LED a dos pines cualquiera, por ejemplo, a los pines 2 y 3. Configurad los dos pines como salida y asignad a uno el

Más allá de lo básico

6

128


valor HIGH y al otro, el valor LOW; después conectad un LED y una resistencia. Esto es posible porque, cuando configuráis un pin en el nivel LOW, este es capaz de recibir co-rriente y, por tanto, se comportará de forma análoga a un pin GND.

Conectad el ánodo del LED al pin 2 y el cátodo, al pin 3; después cargad el sketch que aparece a continuación:

void setup() pinMode(2, OUTPUT); pinMode(3, OUTPUT);

void loop() digitalWrite(3, LOW); digitalWrite(2, HIGH);

En el setup, ambos pines están configurados como salida. En el loop, el pin 3 está situado en el estado bajo y el pin 2, en el estado alto para proporcionar la corriente que alimentará el LED.Para hacer parpadear el LED, el sketch será poco más complejo:

void setup() pinMode(2, OUTPUT); pinMode(3, OUTPUT); digitalWrite(3, LOW);


En el setup, situad en el nivel bajo el pin número 3, de manera que haga de GND. Para que el LED parpadee, en el loop, modificad el estado del pin número 2 cada segundo.

Figura 6.1 - Conexión de un LED y de una resistencia de 470 ohms a dos pines de Arduino.

129

Más allá de lo básico Capítulo 6

Normalmente, conectaréis el ánodo de un LED a uno de los pines de Arduino y el cá-todo se girará hacia tierra (GND). De este modo, encenderéis el LED, aplicando una señal alta al pin preseleccionado. Podéis conectar el ánodo del LED directamente a los 5 V y después el cátodo, mediante una resistencia, a uno de los pines. Si el LED está conectado entre los 5 V y el pin 13, para encenderlo tendréis que enviarle una señal baja al pin:

digitalWrite(13, LOW);

Mientras que para apagarlo enviaréis una señal alta:


Figura 6.2 - Esquema eléctrico del LED conectado al contrario.

Este ejercicio sugiere otro: podéis conectar dos LED a un mismo pin y hacerlos par-padear alternativamente. Estad atentos a cómo conectáis los LED: el primero deberá conectarse entre el pin y el GND, mientras que el segundo se ubicará entre el pin y los 5 V (véase la Figura 6.3).Para este ejercicio, podéis utilizar simplemente el sketch “Blink” que encontraréis en los ejemplos. Modificadlo para que el pin que se utilizará como salida sea el número 11 y no el 13. Cuando la salida esté en el estado bajo, se encenderá el LED rojo; cuando pase al estado alto, se encenderá el LED verde.

LED ondulanteEn el capítulo anterior habéis aprendido a utilizar los pines PWM con la instrucción analogWrite. Aplicando a analogWrite un valor variable con regularidad, podéis hacer que un LED se encienda y se apague muy «suavemente» y con un agradable efecto.Construid un circuito conectando el cátodo de un LED al pin GND y su ánodo, a uno de los seis pines de Arduino marcados con una tilde (~). Los pines que podéis utilizar son

130


3, 5, 6, 9, 10 y 11. No os olvidéis de añadir siempre una resistencia adecuada (véase la Figura 6.4).

Figura 6.3 - Esquema de conexión de dos LED a un pin de Arduino.

Figura 6.4 - Conexión de un LED para control en PWM.

131


Este sketch hará que el valor aplicado a analogWrite cambie cíclicamente pasando de 0 a un valor máximo y viceversa:


void loop() for (int i = 0; i < 255; i++) analogWrite(11, i); delay(10); for (int i = 255; i >= 0; i--) analogWrite(11, i); delay(10);

Este código puede escribirse de un modo más compacto y elegante21, pero utilizando dos ciclos for es mucho más sencillo de entender. En la primera parte del loop un ciclo for incrementa el valor de la variable i llevándola de 0 a 255. La variable i se aplica a analogWrite y modifica directamente la luminosidad del LED. Inmediatamente después podéis ver una pequeña pausa de 10 milisegundos que ralentiza el ciclo y permite vi-sualizar el efecto. El LED empezará apagado y se irá encendiendo gradualmente hasta alcanzar la máxima luminosidad. El segundo ciclo for hará cambiar el valor de i de 255 hasta 0, apagando de forma gradual el LED. El loop se repetirá generando una serie continua de encendidos y apagados.

LED ondulante – versión softwareEl efecto PWM puede obtenerse también utilizando solo la función digitalWrite. Esto significa que podéis modular la intensidad de un LED (o la velocidad de un motor) con cada pin de Arduino. Para simular el efecto PWM, debéis conseguir que el LED se en-cienda y se apague muy rápidamente, más veces en un segundo, y que los tiempos de encendido y de apagado sean controlables, para que podáis decidir si mantener, por ejemplo, el LED encendido durante el 25 % del tiempo.Este es el sketch para realizar una señal PWM en el pin 13 (no es necesario construir ningún circuito, pues utilizaréis el LED incorporado en Arduino):

int i = 0;int pwmsw = 127;


21 Podéis conseguir la versión del sketch entre los ejemplos básicos de Arduino, con el nombre Fade.

132


i = 0;

void loop() if (i < pwmsw) digitalWrite(13, HIGH); else digitalWrite(13, LOW); delayMicroseconds(10); i++; if (i > 255) i = 0;

Para que todo funcione se necesitan dos variables: i, que actúa como contador, y pwmsw, que utilizaréis para configurar la cantidad de PWM (de 0 a 255). Si pwmsw se configura a 127, significa que durante 128 pasos el LED estará encendido, mientras que durante los 128 restantes estará apagado. La variable i contará los pasos. En el setup del sketch, configurad el pin 13 como salida. En el loop hay un test que controla si el número de pasos memorizados en la variable i es menor que el umbral memorizado en pwmsw: si son menores, el LED está encendido, si no, el LED está apagado. El programa ejecuta una pausa de algún microsegundo, utilizando la función delayMicrosenconds(10). Tras esta pausa, el número de pasos aumenta una unidad. Un test comprueba si los pasos han alcanzado el límite de 255 y, en caso afirmativo, los reiniciará de manera que el recuento empiece de nuevo.Tratad de cargar el sketch y podréis encender el LED 13 hasta la mitad de su luminosi-dad (aunque no es un pin PWM).Es posible controlar el recuento de los pasos de manera más refinada, utilizando el operador “módulo” (señalado con %). Así es como se hace:

int pwmsw = 127;


int i = 0;void loop() if ((i%255) < pwmsw) digitalWrite(13, HIGH); else digitalWrite(13, LOW); delayMicroseconds(10); i++;

En este sketch, utilizáis una variable i que aumenta a cada paso del loop con el operador i++. El efecto que se desea obtener es el de una variable que aumenta su valor hasta 255 y después vuelve a empezar desde 0. En lugar de utilizar la instrucción if para controlar si a cada paso la variable supera el valor 255, utilizad el módulo (operador %). El operador módulo devuelve el resto de la división de la variable i entre 255: un número que, si es mayor que i, continúa pasando de 0 a 255. Este truco resulta muy eficiente y elegante.

133


LED RGBA diferencia de un LED común, la versión RGB de este componente puede generar cualquier tipo de color combinando tres colores: rojo (red), verde (green) y azul (blue). Los LED RGB tienen en su interior tres LEDs: uno rojo, otro verde y otro azul y, por tanto, tienen tres terminales. Modificando la intensidad luminosa de los tres LED, es posible crear cualquier color imaginable. Uno de los terminales, el más largo, se deno-mina el “común” y generalmente es el cátodo.

Para generar cualquier tipo de color es necesario modular adecuadamente la lumino-sidad de cada uno de los tres LEDs. Es muy sencillo hacerlo con Arduino conectando los tres ánodos a unos pines PWM. Conectad el LED a los pines 9, 10 y 11 utilizando resistencias con el valor oportuno (entre 220 y 470 ohms) (véase la Figura 6.6).

Figura 6.5 - LED RGB y símbolo de circuito del modelo de cátodo común.

Figura 6.6 - Esquema de co-nexión del LED RGB a Arduino.

134


Aquí tenéis un sketch muy sencillo que podéis utilizar para crear colores aleatorios:

void setup() digitalWrite(9, OUTPUT); digitalWrite(10, OUTPUT); digitalWrite(11, OUTPUT);

void loop() int r = random(255); int g = random(255); int b = random(255); analogWrite(9, r); analogWrite(10, g); analogWrite(11, b); delay(300);

En el loop la instrucción random genera números aleatorios comprendidos entre el 0 y el 255 y los asigna a las variables r, g y b. Las variables se utilizan como argumento de analogWrite para configurar la intensidad luminosa de los tres componentes RGB. El delay sirve para mantener el LED encendido durante un tiempo suficiente.Es posible crear efectos mucho más fascinantes haciendo variar el color progresiva-mente de una tonalidad a otra. El sketch para realizar estos efectos no es demasia-do sencillo, pero podéis encontrar ejemplos en Internet (buscad en Google: “arduino cross fading rgb”).

BotonesEl sensor más sencillo que podéis conectar a Arduino es un botón para interactuar con vuestro proyecto. Los botones deben estar siempre conectados a una resistencia que debe tener un valor de unos diez kiloohms. La resistencia evita que se cree un corto-circuito al pulsar el botón.Los botones que se utilizan habitualmente tienen cuatro pinouts, conectados a pares. El botón se inserta a caballo del surco central de la breadboard. En el esquema de la Figura 6.7 se han utilizado los rail laterales de la breadboard para llevar la alimentación al LED y al botón. Uno de los terminales del botón está conectado directamente a 5 V, mientras que el otro lo está al GND mediante la resistencia de 10 kiloohms y al pin número 13. Al leer el pin 13, se detectarán 0 V, puesto que, aunque hay una resisten-cia, el pin está prácticamente conectado al GND y no pasa corriente. La resistencia conectada de este modo se denomina resistencia pull down. Al pulsar el botón, se crea un contacto y el pin 13 se conecta a la tensión de 5 V: Arduino leerá un valor HIGH, soltando el botón.

135


Figura 6.7 - Esquema de conexión de un LED y de un botón a Arduino.

Es posible conectar el botón de un modo alternativo, para que siempre esté a 5 V y, cuando se pulse, lleve el pin a 0. El funcionamiento es del todo análogo, solo que la señal que lee el pin 13 será siempre alta y se convertirá en baja al pulsar el botón. La re-sistencia en este esquema está conectada a los 5 V y se denomina resistencia pull up.

Figura 6.8 - Esquema de conexión del botón con activación a 0 V.

136


Utilizando el esquema de conexión de la Figura 6.7, aquí tenéis un sketch muy sencillo para leer el botón y modificar el estado del LED: si está encedido, una pulsación del botón lo apagará y viceversa.

int stato_led = LOW;

void setup() digitalWrite(2, OUTPUT); digitalWrite(13, INPUT);

void loop() digitalWrite(2, stato_led); if (digitalRead(13)) stato_led = !stato_led; delay(300);

Para memorizar el estado del LED se utiliza la variable stato_led, que debe situarse fuera de loop y de setup. Si se declarara dentro de la función loop, la variable sería recreada cada vez “perdiendo la memoria”. En el setup, el pin 12 ha sido configurado como entrada y el pin 13, como salida. En el loop, la función digitalWrite enciende o apaga el LED según el estado contenido en la variable stato_led (inicialmente en LOW). La pulsación del botón se controla con digitalRead, que invierte el estado de la varia-ble (utilizando el operador ! de negación). El retraso de 300 milisegundos sirve para evitar que se lean también los rebotes del botón, que podrían hacer que el circuito sea inestable. Así, el programa bloquea durante el tiempo necesario el botón para regresar al estado de equilibrio.

Botón sin resistenciaExiste un ajuste especial de Arduino que permite no agregar una resistencia al botón. Configurando el pin de entrada como INPUT_PULLUP, será el mismo microcontrolador el que conectará una resistencia interna al pin: La resistencia tendrá el pin conectado a 5 V, por lo que, al pulsar el botón, podréis leer el estado LOW.El esquema de conexión se muestra en la Figura 6.9: como podéis observar, el botón está conectado directamente a los pines 12 y GND de Arduino. Para este ejemplo, utilizaréis el LED integrado en la placa.El sketch es muy sencillo: pulsando el botón, encendéis el LED del pin 13.

void setup() pinMode(12, INPUT_PULLUP); pinMode(13, OUTPUT);

137


void loop() int button = digitalRead(12);

if (button == LOW) digitalWrite(13, HIGH); else digitalWrite(13, LOW);

Figura 6.9 - Un botón conectado directamente a Arduino utilizando la configuración INPUT_PULLUP.

En la sección setup del sketch, configuráis el pin 12 como INPUT_PULLUP y el pin 13 como OUTPUT. En la sección loop, el estado del botón se lee con digitalRead(12) y después se guarda en la variable button, valorada con un sencillo test para encender o apagar el LED. Aunque este esquema de conexión es muy simple, es bastante desaconsejable porque suele recoger ruidos y hace que el prototipo sea muy inestable. Siempre es preferible la solución con los pines conectados a tierra.Los botones tienen en su interior un muelle y contactos mecánicos. Al pulsarlo, los contactos se abren y se cierran. Al levantar el dedo, el botón vuelve a su posición ori-ginal, pero en los contactos se producen inevitablemente rebotes que pueden causar falsos contactos. El modo más sencillo de evitar este tipo de problemas es insertar una pausa inmediatamente después de la lectura del valor del botón, como en el sketch del LED que mantiene el estado configurado.

138


Una pausa adecuada sería de más de cien milisegundos:

if (digitalRead(13)) delay(300); //otras instrucciones

Las técnicas para evitar este tipo de problemas se denominan debouncing. Podéis con-sultar un ejemplo de debounce en los sketch de Arduino: Ejemplos > Digital > DeBoun-ce.El sketch cambia el estado del LED cada vez que se pulsa el botón, pero ignora los re-botes que este podría generar. El debounce se realiza calculando el tiempo que trans-curre entre una lectura del botón y la siguiente (generada, quizás, por un rebote). Si el tiempo es superior a un valor prefijado, entonces el valor leído se tiene en cuenta, si no, se ignora. A continuación podéis ver un sketch de ejemplo:

#define BUTTON 2#define LED 13

//el estado del LEDint stato = LOW;

long t = 0;long debounce_delay = 200;

void setup() pinMode(BUTTON, INPUT); pinMode(LED, OUTPUT); digitalWrite(LED, stato);

void loop() int tasto = digitalRead(BUTTON); if (botón) if ((millis()-t) > debounce_delay) stato = !stato; digitalWrite(LED, stato); t = millis();

Para poder utilizar este sketch, conectad un botón al pin 2 de Arduino como se muestra en la Figura 6.7. En la primera parte del listado se declaran las constantes con #define, para indicar los pines utilizados para el botón y el LED; seguidamente será necesaria una variable que memorice el estado del LED. Cada vez que se pulse el botón, el LED cambiará de estado. Se necesitan dos variables más de tipo long, una para almacenar el tiempo actual y otra, para definir el intervalo de debouncing, es decir, el tiempo en el

139


cual es preciso ignorar la presión del botón. En el loop() la variable botón lee el estado del botón y, si este está pulsado, se puede entrar en el primer if. El if anidado controla si la diferencia entre el instante actual y el tiempo guardado es mayor que el tiempo de debouncing. El tiempo guardado corresponde al último cambio de estado del LED. Si la diferencia de tiempo es mayor que el tiempo de debouncing, el LED cambia el estado y el número de millis() actual se almacena en la variable t. El tiempo de debouncing correcto es de unos 200 milisegundos. Para comprobar el funcionamiento del circuito, probad a configurarlo a 10.000 (10 segundos).

Botón en una línea analógica¿Cómo podemos conectar más de un botón a una única línea? ¿Y para qué podría ser útil una cosa así? Porque los pines de Arduino son preciosos y limitados y en un pro-yecto complejo os podrían faltar pines. En estos casos, podéis conectar varios botones a una única línea... pero analógica.Para conectar más de un botón a una única línea analógica, tenéis que crear una fila de resistencias (técnicamente, un divisor) conectada a entre 0 y 5 V. A cada rama, co-nectáis un botón que acaba en uno de los pines analógicos de Arduino. Para mantener estable la entrada analógica, es preciso conectarlo a tierra mediante una resistencia de 1 megaohm.

Así, la entrada analógica está siempre conectada a 0 V y la resistencia de 1 megaohm es lo bastante grande como para no interferir con el divisor. El divisor divide la tensión en tre niveles: 1,25 V, 2,5 V y 3,75 V. Al pulsar el botón S1, la entrada analógica leerá 3,75 V; pulsando S2 tendréis 2,5 V, y con S3 la lectura será de 1,25 V.

Figura 6.10 - Tres botones conectados a una única línea analógica.

140


Para interpretar los botones, tendréis que utilizar una serie de if para controlar el ni-vel de la tensión leído y, por tanto, identificar el correspondiente botón. Para calcular los niveles, debéis tener en cuenta que el valor máximo que puede ser aplicado a las entradas analógicas es de 5 V, que Arduino convertirá en el número 1024. La lectura analógica nunca es precisa y podría oscilar entre un valor máximo y uno mínimo. Por esta razón se ha introducido la variable umbral para definir un intervalo de valores den-tro del cual podría caer la medida.

int umbral = 10;

void setup()

void loop() int level = analogRead(A0);

if ((level > 256 - umbral) && (level < 256 + umbral)) //botón S3 else if ((level > 512 - umbral) && (level < 256 + umbral)) //botón S2 else if ((level > 768 - umbral) && (level < 768 + umbral)) //botón S1

Con este circuito podrían surgir problemas si se pulsan dos o más botones al mismo tiempo. Para obviar este problema, podríais utilizar resistencias con valores distintos entre ellos.Utilizando siempre el mismo principio, podríais serviros de un potenciómetro como si fuera un botón multifunción, identificando un cierto número de zonas, correspondien-tes a las distintas tensiones presentadas en la entrada analógica. Probad a utilizar el sketch multibotón con un potenciómetro (véase la Figura 6.11).

Utilizar un servomotorUn componente que podéis conectar a Arduino de forma muy sencilla es un servo-motor, también denominado RC servo, donde RC significa “Remote Control”, porque estos dispositivos se utilizan en el modelismo de radio control. Un servomotor tiene el aspecto de una pequeña caja dotada de un perno dentado que puede girar. Esta rota-ción no es completa, sino que alcanza un máximo de 180/270° según el modelo. Los servomotores alcanzan la posición establecida y la mantienen.Dentro del servomotor hay:

• un motor de corriente continua;• un potenciómetro, utilizado para detectar la posición del motor;

141


Figura 6.11 - Un potenciómetro utilizado como botón analógico multiposición.

• un grupo de engranajes, para conectar el potenciómetro y el motor y para au-mentar la potencia mecánica del dispositivo desdoblando el motor;

• un pequeño circuito de control que recibe la señal de control, acciona el motor y detecta su posición leyendo el potenciómetro.

Del servomotor salen tres cables: el rojo y el negro sirven para la alimentación y el tercero, amarillo o anaranjado, sirve para proporcionar la señal de control.Estos dispositivos son capaces de desarrollar fuerzas importantes, que se miden como “pares” y se expresan en kilográmetros (kgm). Un servo con un par de 2 kilográmetros puede levantar un peso de 2 kilos conectado a una asta de 1 metro conectada a su vez a su perno. Si reducimos a la mitad la ditancia del asta, conseguiremos levantar 4 kilos a 50 centímetros.

Figura 6.12 - Un servomotor y su símbolo eléctrico.

142


La señal de control debe respetar tiempos precisos, que suelen ser de 0 o 5 V. Para lle-var el servo hasta la posición de 0°, debemos crear una secuencia de impulsos de 5 V, con una distancia entre ellos de 20 milisegundos y una duración de 1 milisegundo. Au-mentando la duración del impulso, el eje del servomotor se desplazará de 0° hasta su valor máximo, por ejemplo, 180° para impulsos con una duración de 2 milisegundos.Utilizar un dispositivo así con Arduino es facilísimo, porque lo podéis conectar direc-tamente sin tener que utilizar transistores. De hecho, de los tres cables, el de control requiere una señal a baja potencia, que sirve solo para proporcionar el control del motor. La potencia (y, por tanto, la corriente) necesaria para que el motor se mueva se adquiere de los dos cables de alimentación que no afectan al microcontrolador. El esquema de conexión es muy sencillo: conectad el cable rojo a los 5 V, el cable negro, al GND y el tercer cable (anaranjado o amarillo), a un pin de tipo PWM.

Figura 6.13 - Esquema de conexión de un servomotor.

La generación de la señal de control de un servomotor no es muy sencilla, pero por suerte Arduino incluye una librería especial para el control de los servomotores que es muy fácil de usar. Aquí tenéis un sketch que retoma uno de los ejemplos incluidos en el IDE de Arduino, dentro de la opción Examples > Servo:

#include <Servo.h> Servo rcservo;

void setup()

143


rcservo.attach(9); void loop() int i = 0; for (i = 0; i <= 180; i++) rcservo.write(i); delay(20); for (i = 180; i >= 0; i--) rcservo.write(i); delay(20);

Antes de empezar, es preciso incluir la librería para la gestión de servomotores (#in-clude <Servo.h>). La librería proporciona el objeto Servo que debéis “declarar”, asig-nándole un nombre (rcservo). El objeto se conecta a un pin de tipo PWM utilizando el método attach(). En el loop, el primer ciclo for aumenta la variable i de 0 a 180, mientras que el segundo ciclo for disminuye el valor de i desde 180 hasta 0. La va-riable i representa los grados de apertura del servomotor y se pasa como argumento al método write(). El pequeño retraso introducido con delay sirve para dar tiempo al servomotor de adquirir la posición establecida.

DisplayUn LED podría no ser suficiente para dar indicaciones a los usuarios de vuestros proto-tipos. Para proporcionar más información, tendréis que utilizar un display o pantalla. El modelo más sencillo es el de siete segmentos (véase la Figura 6.14), es decir, un pequeño bloque que contiene ocho o más LEDs con un cátodo o ánodo común. Algunos de estos componentes pueden tener incluso más de ocho contactos útiles. El número mínimo de segmentos para poder trazar todas las cifras numéricas es siete. El octavo contacto co-rresponde al punto. Podéis conectar directamente una de estas pantallas a Arduino, pero ocuparéis unos ocho pines para controlar una única cifra. Con un solo carácter podéis componer números y también alguna letra: A b C d E F G H I L n O o P S U.Conseguid una pantalla de siete segmentos con un cátodo común y colocadla sobre una breadboard. Para disponer los pines, consultad la hoja de instrucciones del componente. Normalmente, habrá dos filas paralelas de pines de los cuales los centrales son el “co-mún”. Cada segmento va conectado a una resistencia de algunos centenares de ohms. Conectad cada terminal de la pantalla a un pin digital de Arduino y escribid un sketch que encienda los segmentos correctos para componer los distintos símbolos. En la hoja de instrucciones veréis que los siete segmentos se identifican con las siete primeras letras minúsculas del alfabeto.

144


Figura 6.14 - Una pantalla de siete segmentos con cátodo común colocado en una breadboard.

Este es el sketch:

#define A 6#define B 7#define C 8#define D 10#define E 11#define F 12#define G 13

void setup() pinMode(A, OUTPUT); pinMode(B, OUTPUT); pinMode(C, OUTPUT); pinMode(D, OUTPUT); pinMode(E, OUTPUT); pinMode(F, OUTPUT); pinMode(G, OUTPUT);

void loop() cero(); delay(1000); uno(); delay(1000); //etc.

void cero() digitalWrite(G, LOW); digitalWrite(F, HIGH); digitalWrite(A, HIGH); digitalWrite(B, HIGH); digitalWrite(E, HIGH); digitalWrite(D, HIGH); digitalWrite(C, HIGH); void uno() digitalWrite(G, LOW); digitalWrite(F, LOW);

145


digitalWrite(A, LOW); digitalWrite(B, HIGH); digitalWrite(E, LOW); digitalWrite(D, LOW); digitalWrite(C, HIGH); digitalWrite(DP, LOW);

La forma más sencilla de controlar una pantalla de este tipo es encendiendo un seg-mento cada vez mediante siete salidas digitales. Al inicio del sketch, los pines que se deben utilizar están definidos con #define para evitar el consumo de las variables, que, de hecho, quedarán sustituidas antes de compilar el código. Cada pin está asociado a su correspondiente segmento. Para visualizar una cifra tendréis que encender o apa-gar todos los segmentos necesarios. Todo es muy sencillo, pero así utilizaréis siete cables para manejar una única cifra.Podéis reducir el número de pines utilizados adoptando un chip para el control de esta pantalla. Existen distintos modelos, como el 74LS47, que se combina con las pantallas de ánodo común. Para las pantallas de cátodo común, podéis utilizar un chip 4511.Insertad el 74LS47 en una breadboard y conectadlo a la pantalla mediante siete resis-tencias de unos cien ohms. Para mayor facilidad, en la Figura 6.15 no se han dibujado todas las conexiones entre el chip y la pantalla. El chip debe estar necesariamente alimentado a 5 V, que los toma de Arduino.

Figura 6.15 - Conexión de un chip para el control de una pantalla a siete segmentos. Las conexiones a la pantalla están incompletas: para evitar confusiones, he indicado solo los dos primeros cables.

146


La numeración de los pines de los chips va siempre en sentido antihorario: el pin número 1 se puede identificar gracias a una evidente muesca situada en una de sus extremida-des, o bien por la presencia de un pequeño punto en el cuerpo del circuito integrado. No os olvidéis de conectar el pinout número 8 del chip a uno de los GND de Arduino.Para visualizar un símbolo en la pantalla, debéis utilizar los pinouts A, B, C y D, apli-cando el número que se debe mostrar en numeración binaria. Seguid las indicaciones de la Tabla 6.1, teniendo en cuenta que “1” significa HIGH y “0”, LOW.

Tabla 6.1 - Configuración de las líneas ABCD del 74LS47 para el control de la pantalla de siete segmentos.

A B C D Pantalla

0 0 0 0 00 0 0 1 10 0 1 0 20 0 1 1 30 1 0 0 40 1 0 1 50 1 1 0 60 1 1 1 71 0 0 0 81 0 0 1 9

Con esta solución, necesitaréis solo cuatro cables para mostrar una cifra cualquiera. Después de haber construido el circuito en una breadboard, cargad el siguiente sketch:

void setup() pinMode(10, OUTPUT); pinMode(11, OUTPUT); pinMode(12, OUTPUT); pinMode(13, OUTPUT); Serial.begin(9600);

int count = 0;

void loop() byte a = bitRead(count, 0); byte b = bitRead(count, 1); byte c = bitRead(count, 2); byte d = bitRead(count, 3); Serial.print(d); Serial.print(c); Serial.print(b); Serial.println(a);

147


digitalWrite(2, a); digitalWrite(3, b); digitalWrite(4, c); digitalWrite(5, d); count++; if (count == 10) count = 0; delay(1000);

El código configura los pines 10, 11, 12 y 13 como salidas. Los pines están conectados a las entradas A, B, C y D del chip. Una variable denominada count memoriza el recuento que se repetirá continuamente de 0 a 9. El valor de count será convertido en binario con la función bitRead. Los bits calculados serán aplicados directamente a los pines de salida. También podéis leer el recuento en el Serial Monitor.Para controlar más elementos no necesitaréis más chips: con uno es suficiente y pue-de controlar más de una pantalla, conectadas en paralelo a sus salidas. Arduino, en este caso, encenderá una pantalla por vez en una secuencia muy rápida, de manera que pueda engañar al ojo y parezca que todos los elementos están encendidos a la vez. Para habilitar cada una de las pantallas, debéis utilizar transistores conectados a los pines de Arduino: con esta solución, utilizaréis cuatro salidas más una para cada elemento de siete segmentos.

Figura 6.16 - Control de más elementos de siete segmentos con un único chip 74LS47.

Cuando apliquéis una señal HIGH a la base del transistor, este dejará pasar la corriente que discurre a través del terminal común. Aplicando una señal LOW a la base, el transis-tor realizará un corte y la pantalla permanecerá apagada.

148


LCDLas pantallas de siete segmentos son bastante limitadas e, incluso, un poco retros. Para mostrar mensajes utilizando todas las letras posibles y símbolos gráficos, es mejor utili-zar pantallas LCD, es decir, de cristal líquido. Estas pantallas consumen menos corriente que los LED, son más flexibles y tienen un coste accesible. Podéis comprar pantallas que muestran caracteres con un sistema modular de siete o más segmentos (como en las cal-culadoras electrónicas más económicas), o pantallas que usan una matriz de puntos con la cual se representa cualquier signo gráfico. Las pantallas están controladas por chips especiales que gestionan todas las señales eléctricas necesarias. La comunicación se lle-va a cabo con interfaces seriales o paralelas, a través de las cuales se envían los datos. Las interfaces seriales son preferibles porque utilizan un número de cables muy limitado. Las pantallas más conocidas son las que utilizan el chipset Hitachi 44780. Son tan utilizadas que están consideradas como estándar. La pantalla está montada sobre una placa electrónica y el chip de control está en la parte inferior. En un borde de la placa hay una fila de contactos (véase la Figura 6.17).

Figura 6.17 - Pinout de la pantalla LCD Hitachi 44780.

Esta es la descripción de los pines de la pantalla LCD:• GND – para conectar al pin GND de Arduino;• 5V – es el pin para alimentar la pantalla;• Contraste – habitualmente se conecta a un trimmer de 10 kiloohms ajustado

entre 5V y GND. Si la regulación no se ajusta correctamente, puede ser que no se vea nada;

149


• RS (Register Select) – modifica el comportamiento de la pantalla. Cuando se encuentra en el estado bajo, la pantalla está en “command mode” y cuando se encuentra en el estado alto está en “data mode”;

• RW (Read/Write) – LOW para “write mode” y HIGH para “read mode”. Nor-malmente la pantalla está ajustada en “write mode”, para que sea posible en-viar datos y que aparezcan en la pantalla. En “read mode” es posible leer lo que está mostrando la pantalla, aunque este caso es poco frecuente;

• E (Clock enable) – la pantalla puede elaborar datos solo cuando el reloj inter-no está habilitado y proporciona la hora al chip. Con este pin, podéis activar o desactivar la pantalla;

• DB0-DB7 – son los pines para los datos. La pantalla puede recibir datos en ocho o cuatro cables por vez. Habitualmente se utilizan solo cuatro cables porque no se necesitan “grandes” prestaciones y ocho cables son muchos, por lo que los pines 7, 8, 9 y 10 no se utilizan;

• LED+ – para conectar a los 5 V, encendiendo así la retroiluminación;• LED- – pin negativo de alimentación para la retroiluminación.

Figura 6.18 - Esquema de conexión de una pantalla Hitachi 44780 (o compatible) a Arduino.

150


Para el control de la pantalla existe una práctica librería incluida en el IDE. Tras haber conectado la pantalla a Arduino, abrid un nuevo sketch y copiad las siguientes instruc-ciones:

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() lcd.begin(16, 2); lcd.print("hello, world!");void loop()

En primer lugar, tenéis que incluir la librería LiquidCrystal.h y después crear un objeto LiquidCrystal asignándole un nombre (lcd) e indicando a la librería cómo está conec-tada la pantalla a Arduino. Los números pasados como parámetros indican (en orden) los pines de Arduino a los cuales están conectados los pines de la pantalla RS, E, D4, D5, D6 y D7.En el setup la instrucción lcd.begin(16,2) configura una pantalla de dos filas y 16 co-lumnas. Para mostrar un texto, basta con utilizar lcd.print().Existen otros comandos para gestionar la pantalla. Por ejemplo, podéis colocar el cur-sor en la posición que deseéis utilizando:

setCursor(columna, fila);

Como numeración, las columnas y las filas parten todas de 0. Podéis modificar el ejemplo anterior mostrando un segundo mensaje al inicio de la segunda línea, por tanto, en la columna 0 y la fila 1:

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() lcd.begin(16, 2); lcd.print("Recuento:");

int contador = 0;

void loop() lcd.setCursor(0, 1); lcd.print(contador); contador++; delay(1000);

151


Estos son otros comandos:• lcd.clear() elimina el contenido de la pantalla;• lcd.home() recoloca el cursor en la posición inicial;• lcd.cursor() visualiza el cursor;• lcd.noCursor() oculta el cursor;• lcd.blink() hace parpadear el cursor;• lcd.noBlink() detiene el parpadeo del cursor;• lcd.noDisplay() desactiva la pantalla guardando el contenido;• lcd.display() reactiva la pantalla;• lcd.scrollDisplayLeft() desplaza el contenido de la pantalla hacia la izquierda;• lcd.scrollDisplayRight() desplaza el contenido de la pantalla hacia la derecha.

Con las pantallas gráficas es posible definir caracteres personalizados. Aquí tenéis un ejemplo:

#include <LiquidCrystal.hLiquidCrystal lcd(12, 11, 5, 4, 3, 2);Byte personalizado [8] = B01110, B10101, B10101, B11111, B01010, B10001, B10001, B00000;

void setup() lcd.createChar(0, personalizado); lcd.begin(16, 2); lcd.write(0);void loop()

El carácter se define utilizando una matriz formada por ocho filas de cinco bits. Podéis especificar cada fila bit por bit anteponiendo la letra B a la secuencia de números. Para cargar el carácter en pantalla, se utiliza la función createChar(), que lo asigna a un número (en este caso, al 0). Para imprimir el carácter, utilizad lcd.write(n), donde n es el número asignado al nuevo carácter. Podéis crear como máximo ocho caracteres personalizados.A veces, las pantallas están equipadas con una placa de control de serie que utiliza el estándar I2C (véase el capítulo sobre las comunicaciones), que se aplica en la parte posterior del LCD y que requiere solo dos cables para la comunicación con Arduino.

152


La placa puede funcionar en distintas modalidades de serie: utilizando el protocolo I2C22 o bien con los dos clásicos cables TX y RX. Las conexiones pueden variar entre distintos modelos y normalmente es posible elegir entre la comunicación de serie e I2C cortocircuitando un pequeño puente. Cuando el módulo se utiliza en la modalidad I2C, se usan los pines SDA y SCL de Arduino y de la pantalla. En Arduino, el pin SDA coincide con el pin A4, mientras que SCL coincide con A5. Si utilizáis la modalidad de serie, no os olvidéis de intercambiar RX y TX entre ellos: RX de la pantalla se conecta a TX de Arduino y viceversa. En Arduino, el pin RX corresponde al pin 0, mientras que TX se encuentra en el pin 1.Cuando carguéis el sketch y la pantalla esté en modalidad de serie, desconectadla para poder realizar la carga.Para gestionar la placa de serie, es necesario descargar la librería LCD03 desde la si-guiente dirección: http://andatche.com/code/arduino/lcd03/. Esta librería gestiona la comunicación mediante el protocolo I2C (un tipo de interfaz de serie) y permite utilizar las pantallas 16x2 y 20x4 de manera muy sencilla. Los comandos disponibles en la libre-ría son compatibles con los que forman parte de la biblioteca original de Arduino.

Figura 6.19 - Conexión de una pantalla (vista por detrás) con el módulo de serie a Arduino.

Registros de desplazamiento (shift register)Para realizar efectos especiales, como cubos de LED, o para aumentar el número de entradas y salidas de Arduino, podéis conectar un registro de desplazamiento, es de-cir, un chip en el cual podéis insertar datos desde una entrada de serie (que ocupa un único cable) y que puede controlar ocho o más salidas adicionales.Los registros se distinguen por el tipo de entrada y de salida, que pueden ser de serie o paralelos. Una línea de serie está formada por un único cable por el cual transmitire-mos los bits uno tras otro, a tiempo de reloj. Una línea paralela utiliza más cables por

22 El protocolo I2C fue inventado por Phillips en 1982 y se utiliza para que distintos circuitos se comuniquen entre ellos mediante únicamente dos cables.

153


los cuales transmitiremos todos los bits a la vez. Las líneas paralelas son más rápidas, pero utilizan un mayor número de cables. Tenemos, así, cuatro tipos de registros:

• SISO – Serial Input / Serial Output;• SIPO – Serial Input / Parallel Output;• PISO – Parallel Input / Serial Output;• PIPO – Parallel Input / Parallel Output.

Para añadir ocho nuevas salidas digitales, es necesario conectar un SIPO de 8 bits. Para añadir ocho nuevas entradas, se necesita un PISO de 8 bits. La línea de serie de estos simples dispositivos está formada por un único cable sobre el cual se presenta-rán los datos. El registro está sincronizado proporcionándole una señal de reloj.Al conectar un SIPO a un Arduino, necesitaréis dos salidas digitales: una generará el reloj, y la otra presentará los datos al registro. Primero, cargáis el estado de las ocho salidas en ocho golpes. Cuando termine la carga, «activáis» los datos cargados en un pin del registro. Ocupando solo tres pines de Arduino, podréis gestionar ocho nuevas salidas. Existen distintas familias de chips y debéis estar atentos a los componentes que queréis conectar: es posible conectar un LED sin demasiadas complicaciones, pero hay que tener en cuenta las mismas precauciones que las que se utilizan para Arduino.El chip 74HC164 es un registro de desplazamiento (shift register) de tipo SIPO. Con solo tres líneas podemos controlar ocho señales de salida. Una entrada es para el reloj, otra es para el reset y otra es la entrada para los datos. El 74HC164 tiene, en realidad, dos entradas denominadas A y B que están conectadas internamente a un puerto ND. La entrada B se puede conectar directamente a los 5 V y se utilizará la línea A como entra-da de serie para los datos. Para cargar los datos se debe presentar un bit cada vez en la entrada y hacer que el reloj cumpla un paso, es decir, hacer que pase del estado bajo al alto. Los bits presentes en las celdas del registro se desplazarán a cada golpe del reloj. Un bit saldrá por el final de la fila y un nuevo bit podrá entrar en la primera celda. El reloj es una señal de onda cuadrada que debe estar sincronizado con los datos.

Figura 6.20 - El registro de desplazamiento 74HC164 y el esquema de su funcionamiento.

154


Veamos cómo conectar un registro de desplazamiento 74HC164 a Arduino para aña-dir ocho nuevas salidas digitales. Preparad los siguientes componentes:

• una breadboard;• un circuito integrado 74HC164;• ocho LEDs;• ocho resistencias de 220 ohms;• un Arduino Uno;• un condensador de 0,1 microfaradios;• jumper o cable para realizar las conexiones.

El esquema eléctrico del circuito de prueba del registro de desplazamiento se muestra en la Figura 6.21.

Figura 6.21 - Esquema de conexión del chip 74HC164 a Arduino.

Seguid las siguientes indicaciones:• acoplad el chip 74HC164 en el centro de la breadboard;• unid los raíles laterales de la breadboard para tener alimentación en ambos lados;• colocad el condensador de bypass de 0,1 microfaradios en los dos raíles, conec-

tado entre los 5 V y la tierra (GND);• conectad el pin 7 del chip a tierra y el chip 14, a los 5 V;

155


• insertad las resistencias de 220 ohms y los LEDs, intentando ser muy ordena-dos. Empezad por los pines 3, 4, 5 y 6. Después pasad al lado opuesto del chip e insertad LEDs y resistencias en los pines 10, 11, 12 y 13;

• conectad el pin 2 (entrada B) al raíl de 5 V;• unid con un jumper el pin 8 del chip (CLOCK) al pin 3 de Arduino;• unid con un jumper el pin 9 del chip (CLEAR) al pin 4 de Arduino;• unid con un jumper el pin 1 del chip (entrada datos A) al pin 5 de Arduino;• llevad los 5 V y la masa (GND) de Arduino a los raíles de alimentación de la

breadboard;• preparad el sketch para Arduino;• conectad Arduino con el cable USB y transferid el sketch.

Figura 6.22 - El circuito realizado en una breadboard.

void setup() pinMode(3, OUTPUT); //clock pinMode(4, OUTPUT); //clear pinMode(5, OUTPUT); //datos //enviamos una señal de reset digitalWrite(4, LOW); delay(100);

156



//preparo el reloj digitalWrite(3, LOW);

//cargamos un solo bit igual a 1 //el reloj sube digitalWrite(3, HIGH); //transmito el primer bit digitalWrite(5, HIGH); delay(10); //el reloj baja digitalWrite(3, LOW);

void loop() //el reloj sube digitalWrite(3, HIGH); delay(300); //transmito solo ceros... digitalWrite(5, LOW); //el reloj baja y los datos se desplazan digitalWrite(3, LOW);

El sketch, en primer lugar, resetea el chip; después, con un golpe de reloj, carga un primer bit “1”. En el loop no se cargan otros bits, pero el reloj hace que se desplace el único bit incluido en el setup, hasta que no “sale” del registro. Los LED deberían en-cenderse uno a uno. Para repetir la secuencia, pulsamos el botón RESET de Arduino. El problema de este tipo de circuitos es que no se puede ajustar una salida individual de forma independiente, sino que debemos cargar los ocho bits en secuencia aunque solo tengamos que modificar uno de ellos. Aun así, la carga es muy rápida.El circuito integrado 74HC165 es un registro PISO, con el cual podremos añadir ocho entradas adicionales para nuestro microcontrolador. El funcionamiento del chip es muy parecido al del 74LS164. Antes de conectar un chip, buscad en Internet su hoja de especificaciones técnicas y comprobad la disposición de los pines.

MódulosCuando las cosas empiezan a ser más complejas, podría ser necesario dividir vuestro proyecto en varios archivos o módulos. Con Arduino resulta sencillo añadir al proyecto un archivo en el cual colocar algunas funciones de uso frecuente. Así, tendréis un archi-vo principal de dimensiones limitadas, acompañado de uno o varios archivos adiciona-les. Los archivos adicionales se añaden automáticamente al proyecto y simplemente tendréis que crearlos y escribir el código que sea necesario. Veamos un sencillo ejemplo.Cread un nuevo sketch y copiad las siguientes instrucciones:

157



void loop() blink(13, 1000);

En el loop insertáis la función blink(), que definiréis en un módulo adicional. Para crear un módulo, pulsad sobre el botón de punta de flecha situado a la derecha de la barra de herramientas. En el menú que se despliega, seleccionad New Tab para crear un nuevo módulo. Asignad un nombre al módulo; en este caso, “blink.h” podría ser una buena opción.

Figura 6.23 - Añadir un nuevo módulo al proyecto.

Para acceder al nuevo módulo, pulsad sobre la correspondiente pestaña de la barra de herramientas. Si “blink.h” no se encuentra seleccionado, activadlo con un clic de ratón y escribid la función que se utilizará en el módulo principal (véase la Figura 6.23).

158


void blink(int led, int del) digitalWrite(led, HIGH); delay(del); digitalWrite(led, LOW); delay(del);

Seleccionad el módulo principal y, en la parte superior, añadid #include "blink.h";, después pulsad Verify para compilar todos los archivos y cargadlos en Arduino.Intentad crear módulos que contengan funciones homogéneas, para que después sea fácil encontrar los fragmentos de código entre los distintos archivos de vuestro pro-yecto.

Figura 6.24 - Los módulos del proyecto son accesibles pulsando sobre las pestañas de la barra de herramientas.

LibreríasAlgunos dispositivos cuentan con librerías para facilitar su uso. Vosotros también po-déis crear librerías para ampliar las funcionalidades de Arduino.

159


Para añadir una librería específica a vuestro proyecto, utilizad la opción del menú Sketch > Include Library; la librería ya debe estar instalada en el entorno de desarrollo. Para insertar una nueva, podéis agregar un archivo comprimido (zip) utilizando la op-ción de menú Add .ZIP library (del menú Sketch > Include Library). Sin embargo, cada vez es menos frecuente instalarlas manualmente, puesto que podéis encontrarlas en el Library Manager, al que podéis acceder desde Sketch > Include Library > Manage Library.

Figura 6.25 - La ventana del Library Manager.

Escribid el nombre de la librería que queréis agregar y, una vez identificada, pulsad sobre la línea correspondiente: aparecerá el botón Install. Pulsadlo para iniciar la ins-talación de la librería.Las librerías se pueden instalar también manualmente, descargando el archivo pro-porcionado por el productor y descomprimiéndolo dentro de la carpeta denominada «libraries» de vuestro Sketchbook. Podéis encontrar la ruta de vuestro Sketchbook en el panel Preferences de Arduino.

160


Escribir una libreríaSi creéis que el código que habéis escrito podrá ser reutilizado en otros proyectos, podéis transformarlo en una librería. Crear una librería no es muy difícil. Una librería está formada por dos archivos: uno con la descripción del contenido y otro, con el código. Ambos normalmente tienen el mismo nombre. El archivo con las definiciones tiene la extensión .h y también se conoce como header; el archivo con el código tiene la extensión .cpp.Para crear vuestra propia librería, añadís una carpeta dentro del directorio denomi-nado “libraries” de vuestro Sketchbook. Renombráis la carpeta como “Blink” y, en su interior, creáis dos archivos denominados “Blink.h” y “Blink.cpp”. Abrís los archivos con un editor de textos común. El archivo Blink.h contiene la definición de la librería. En este caso, vais a crear una clase para hacer parpadear un LED, denominada Blink.La clase se declara asignándole precisamente un nombre y describiendo aquello que presenta al mundo exterior. En este caso, la clase presentará:

• Blink(int pin) para que la podáis “crear”. Este método se denomina también “constructor”;

• void blink(int tim) para que el LED parpadee.

La clase incluye también una variable denominada _led que memorizará el número de pin al cual se encuentra conectado el LED. Esta variable está protegida en la parte pri-vate y no puede verse fuera de la clase Blink. Esta es la definición completa de la clase:

class Blink public: Blink(int pin); void blink(int tim); private: int _pin;;

Para crear un archivo header correcto es necesario incluir siempre ciertas instruccio-nes especiales que evitan que la librería se incluya más de una vez en los proyectos (de hecho, podría conllevar errores). Así, al inicio de la librería, escribid:

#ifndef Blink_h#define Blink_h

Después, agregad lo siguiente:

#include "Arduino.h"

para poder utilizar las funciones de Arduino dentro de vuestro código. Insertad vues-tra definición de clase y, después, terminad el archivo con:

#endif

161


Al inicio del archivo, escribid una breve descripción. Este es el código completo:

/* Blink.h – Librería para hacer parpadear un LED*/#ifndef Blink_h#define Blink_h

#include "Arduino.h"

class Blink public: Blink(int pin); void blink(int tim); private: int _pin;;

#endif

Guardáis el archivo, abrís Blink.cpp y escribís la implementación de la librería, es decir, el código que hará que esta funcione. En el archivo, debéis escribir las funciones que habéis definido en el archivo header, Blink.h. Para vincular las funciones con sus defi-niciones y conseguir así que Arduino lo detecte, debéis añadir el nombre de la clase seguido de dos puntos (por ejemplo Blink::) antes de sus nombres. Este es el código completo del archivo:

/* Blink.cpp - */

#include "Arduino.h"#include "Blink.h"

Blink::Blink(int pin) pinMode(pin, OUTPUT); _pin = pin;

void Blink::blink(int tim) digitalWrite(_pin, HIGH); delay(tim); digitalWrite(_pin, LOW); delay(tim);

Al inicio del archivo podéis añadir un comentario. No os olvidéis de escribir los include para el archivo Blink.h y para Arduino.h. A continuación, abrid Arduino y cread un nue-vo sketch, después añadís la nueva librería abriendo el menú Sketch > Include Library.

162


En la sección Contributed Libraries podréis encontrar la opción Blink (véase la Figura 6.26). El sketch que debe cargarse en Arduino tendrá este aspecto:

#include <Blink.h>

Blink blink(13);

void setup()

void loop() blink.blink(500);

Tras haber incluido vuestra librería Blink, debéis definir el objeto Blink asignándole un nombre (blink) y el pin que controlará. En la sección loop() del sketch podréis hacer parpadear un LED con el método blink().

Figura 6.26 - La librería Blink se encuentra instalada correctamente.

163

Después de haber presentado las técnicas de programación

y el cableado más común, ya estáis preparados para enfren-

taros y entender algunos argumentos más complejos relati-

vos a Arduino que no se utilizan en el día a día, pero que os po-

drán ser de gran ayuda para realizar proyectos con un toque profesional y resolver determinados problemas.

InterrupcionesLas interrupciones son un mecanismo que permite a un microcontrolador gestionar eventos especiales. Imaginad que vuestro Arduino está ocupado ejecutando las ope-raciones escritas dentro del loop. A menudo ocurre que al inicio del loop es necesario controlar el estado de algunos botones con instrucciones digitalRead, seguidas de mu-chas otras instrucciones. Podría pasar bastante tiempo antes de volver a leer el estado de los botones. Si la presión de un botón está conectada a una acción importante, Arduino debería abandonar inmediatamente lo que está haciendo para gestionar el evento al instante. Ocurre algo parecido cuando os suena el teléfono de forma in-esperada: normalmente, dejáis lo que estáis haciendo para correr a responder. Una interrupción es una especie de llamada urgente para Arduino: correrá a responder abandonando lo que está haciendo. Este mecanismo es muy útil en los casos en que, ante un evento «hardware», es necesario dar una respuesta rápida, por ejemplo, para responder rápidamente a la pulsación de un botón o leer el estado de un encoder rotativo.

Programación avanzada

7

164


Las interrupciones se pueden activar detectando la llegada de una señal a algunos pi-nes. Arduino Uno solo puede escuchar a dos pines, mientras que Arduino Mega tiene seis pinouts habilitados: consultad la Tabla 7.1 para conocer los pines habilitados. El mecanismo de las interrupciones permite estructurar los programas de manera dis-tinta: no existe un único ciclo que se repite y que gestiona las lecturas y las escrituras en los pines, sino que es posible introducir eventos.

Tabla 7.1 - Los pines habilitados para las interrupciones en distintas placas Arduino.

Placa Pines habilitados para interrupciones

Uno 2, 3Mega, Mega 2560 2, 3, 18, 19, 20, 21

Micro, Leonardo 0, 1, 2, 3, 7

Zerotodos los pines digitales,

excepto el número 4Due todos los pines digitales

Para utilizar las interrupciones deberíais:• avisar a Arduino que pretendéis utilizarlas;• definir una función que será llamada cuando se verifique una interrupción;• vincular la función a uno de los pines habilitados;• indicar qué tipo de señal activará la llamada.

attachInterrupt(número_interrupción, función, tipo_de_señal);

Las interrupciones están asociadas a algunos pines con números: es preciso que re-cordéis que para habilitarlas en el pin 2 tendréis que utilizar el número 0 (y así su-cesivamente para el resto de los pines). Como es muy fácil confundirse y escribir un código poco portable, es mejor utilizar la siguiente función:

digitalPinToInterrupt( número_del_pin )

que convierte el pin deseado en el índice correcto y garantiza la portabilidad del sketch de un modelo de Arduino a otro.La condición sobre la señal que debe producir la interrupción puede especificarse con:

• CHANGE – para producir una interrupción en cada cambio de señal (tanto de HIGH a LOW, como de LOW a HIGH);

• RISING – cuando la señal pasa de LOW a HIGH;• FALLING – cuando la señal pasa de HIGH a LOW;• LOW – cada vez que el pin está en LOW;• HIGH – cada vez que el pin está en HIGH (funciona solo con Arduino Due);

165

Programación avanzada Capítulo 7

La función que se utilizará para gestionar la interrupción se denomina también ISR (In-terrupt Service Routines) y no puede recibir parámetros, ni devolver ningún resultado. En general, debería ser una función bastante breve y rápida. En ella podréis utilizar variables presentes en el sketch (variables globales), que, sin embargo, deberán ser declaradas como volatile; de no ser así, podrían ser modificadas por otras partes del código que quizás no controláis. En el caso de las interrupciones, una variable podría ser modificada tanto por el código “normal” como por instrucciones presentes en una llamada de gestión de una interrupción. Las variables de este tipo proceden de la RAM y no de los registros del microcontrolador, que durante las llamadas a interrupción podrían proporcionar valores incorrectos.Las funciones como millis() y delay(), que trabajan con la medida del tiempo, no fun-cionan en estos contextos, puesto que internamente utilizan las interrupciones, así como las transmisiones a lo largo de la serie. La función delayMicroseconds(), en cam-bio, debería funcionar correctamente porque utiliza un sistema distinto.Conectad un botón al pin 3 y cargad el siguiente sketch en Arduino.

volatile int estado = LOW;

void setup() pinMode(13, OUTPUT); attachInterrupt(digitalPinToInterrupt(3), cambia, CHANGE);

void loop() digitalWrite(13, estado);

void cambia() estado = !estado;

Al pulsar el botón, generáis una interrupción que modificará el estado del LED.La variable estado debe poder ser utilizada también dentro del método de gestión de las interrupciones, por lo que debe ser del tipo volatile.

Si hay varias funciones para la gestión de las interrupciones, solo podrá ejecutarse una cada vez.

En algunos casos especiales, el mecanismo de las interrupciones puede ser inhibido, porque podría causar problemas. Por lo tanto, es preciso evitar que Arduino se «dis-traiga» de lo que está haciendo.Con detachInterrupt() se desactiva el mecanismo de las interrupciones y Arduino no volverá a escuchar el pin que había sido señalado.

166


Conectad un botón al pin 3 y cargad el siguiente sketch:

volatile int estado = LOW;

void setup() pinMode(13, OUTPUT); attachInterrupt(digitalPinToInterrupt(3), cambia, RISING);

void loop() digitalWrite(13, estado);

void cambia() estado = !estado; //así solo lo hace una vez detachInterrupt(digitalPinToInterrupt(3));

Antes de finalizar la ejecución de la función cambia(), detachInterrupt() desregistra el pin 3 y, al pulsar de nuevo el botón, ya no ocurrirá nada.Para deshabilitar por completo el mecanismo de las interrupciones se utiliza esta función:

noInterrupts();

Para rehabilitar todas las interrupciones:

interrupts();

Así, es posible crear «secciones protegidas» en las cuales llevar a cabo secuencias de operaciones que no pueden ser interrumpidas.

EEPROM y variables persistentesEn ocasiones es necesario guardar informaciones para poder reutilizarlas al volver a encender el circuito. Podríais haber construido una placa con una pantalla LCD y bo-tones en la cual hubiérais previsto una sección para la configuración. Puede ser que vuestro circuito tenga que conectarse a una red WIFI y queráis memorizar el nombre de la red y la contraseña: sería muy pesado tener que escribir esta información en cada encendido. Arduino puede memorizar algunas informaciones de manera perma-nente, como ocurre con los sketch que cargáis. Un microcontrolador tiene tres tipos de memoria:

• flash – una memoria permanente y reescribible unas 10.000 veces, similar a un disco duro, donde está escrito el sketch y el bootloader, es decir, el programa que permite la carga de los códigos por USB. Los tamaños van de 8 a 32 kB en los distintos modelos ATmega;

167


• RAM – es la memoria de solo lectura, es muy rápida y los datos memorizados se pierden cuando se corta la alimentación. Normalmente, sus dimensiones son reducidas, de 1 a 4 kB, y se utiliza para mantener las variables del programa;

• EEPROM – es una memoria permanente que puede ser utilizada para guar-dar ajustes y parámetros que no deben desaparecer al cortar la alimentación. Las dimensiones son reducidas (sobre 1 kB o menos) y puede ser sobreescrita 100.000 veces.

La EEPROM es la memoria ideal para memorizar parámetros y ajustes. Para trabajar con ella es necesario incluir la librería EEPROM.h en el sketch. Para escribir un dato, es preciso indicar también su posición, es decir, la dirección, utilizando un número que parte de 0 y que deberíais recordar para recuperar la información memorizada. Las “celdas de memoria” de la EEPROM tienen el tamaño de 1 byte, por lo que cada dirección señala a una única celda.Así es como se memoriza un número:

#include <EEPROM.h>

int dirección = 0;

void setup() int val = 101; EEPROM.write(dirección, val);

void loop()

Tras haber importado la librería EEPROM.h, debéis utilizar el método write para escri-bir el byte que queréis memorizar. En el sketch se ha almacenado un número sencillo (101) en la posición 0 de la memoria. Cargad el sketch y apagad Arduino. Conectad de nuevo la placa y escribid este nuevo sketch para leer el valor:

#include <EEPROM.h>

int dirección = 0;

void setup() Serial.begin(9600); int val = EEPROM.read(dirección); Serial.print("valor leído por EEPROM: "); Serial.println(val);

void loop()

168


La lectura de una “celda de memoria” se realiza con el método read, especificando la dirección de la celda que hay que leer. La librería EEPROM disponde de otros métodos:

• EEPROM.length() – proporciona el tamaño de la EEPROM;• EEPROM.update(dirección, dato) – sobreescribe un valor si es distinto del actual.

Este método es más rápido que el simple comando de escritura;• EEPROM.put(dirección, dato) – es similar a la instrucción write, pero puede escri-

bir datos complejos o mayores que 1 byte;• EEPROM.get(dirección, dato) – junto con la put, lee datos complejos o mayores

que 1 byte.

Cuando utilizáis put() y get() para escribir un entero que ocupa 4 bytes, el número se escribirá en las siguientes celdas a partir de la dirección proporcionada. Si escribís el número en la dirección 0, ocupará las celdas de la 0 a la 3. Si escribís un segundo dato, tendréis que acordaros de empezar en la dirección 4 para no sobreescribirlo. Para escribir una cadena, es preciso guardar los caracteres uno a uno.La EEPROM tiene un espacio limitado, como la RAM. Puede ser que, en algunos ca-sos, necesitéis más espacio, para memorizar, por ejemplo, textos largos. Trabajando con cadenas, se puede consumir rápidamente mucha memoria, porque cada carác-ter consume 1 byte, es decir, una celda de memoria. Arduino ofrece otra posibilidad: la memorización en la flash memory, mediante la palabra clave PROGMEM. Para utilizar PROGMEM tenéis que incluir la correspondiente librería pgmspace.h y después crear una variable global (es decir, externa a loop() y setup()) de este modo:

const char mensaje[] PROGMEM = "Hello World!";

Para leer este tipo de variables, debéis utilizar un sketch como el siguiente:

#include <avr/pgmspace.h>const char mensaje[] PROGMEM = "Hello World!";

void setup() Serial.begin(9600); for (int i = 0; i < 12; i++) char ch = pgm_read_byte_near(mensaje + i); Serial.print(ch);

void loop()

La cadena mensaje debe ser leída carácter a carácter utilizando la función pgm_read_byte_near. El parámetro de la función es el nombre de la variable a la cual se ha sumado el contador i. Este aspecto puede parecer extraño: a todos los efectos, utilizando la cadena de este modo, se está utilizando su dirección y no su contenido. La cadena

169


mensaje podría ser memorizada en la posición 1234 de la memoria y funciona como un “puntero” para los datos.Si se desconoce la longitud de la cadena, podéis utilizar:

strlen_P(mensaje)

Debéis tener presente que cada cadena de texto que utilizáis queda normalmente me-morizada en la RAM y, por tanto, la memoria se puede agotar fácilmente. Un método para memorizar cadenas en la flash es mediante el uso de F():

Serial.print(F("Texto largo escrito en la serie y almacenado en la FLASH"));

Lenguaje ensambladorEl ensamblador es un lenguaje de nivel muy bajo: al utilizarlo, estáis hablando casi la misma lengua que la calculadora. Con el ensamblador, se trabaja directamente con las partes del chip y es posible, por ejemplo, copiar datos de un registro a otro o llevar a cabo operaciones básicas. El ensamblador se puede convertir fácilmente en código máquina con una simple tabla de conversión. El C y los lenguajes de alto nivel nos fa-cilitan mucho la vida, aunque después deban ser convertidos en secuencias de código máquina del cual a menudo no sabemos nada. Por lo general, no se sabe cómo una variable o un ciclo for se convierten en código máquina.Si bien no es mi intención incluir en este libro un curso de ensamblador, os mostraré cómo utilizarlo directamente dentro del IDE de Arduino, así como algún ejemplo prác-tico.Para empezar, el lenguaje ensamblador puede ser codificado directamente en el sketch mediante una función especial:

__asm__("instrucciones en lenguaje ensamblador");

Es posible utilizar también una forma más elegante, sin signos de subrayado:

asm volatile ( " asm " );

Cada instrucción debe estar en una línea independiente y, para pasar a la siguiente, es preciso insertar los caracteres \n\r.Con una instrucción del ensamblador, podéis resetear la placa con un efecto parecido a la pulsación de la tecla RESET.

asm volatile (" jmp 0 ");

La función hace que el cursor del programa empieza de 0, que equivale a hacer un reset sin necesidad de apagar “eléctricamente” la placa. El lenguaje ensamblador es

170


mucho más dfifícil de escribir que el C y requiere altos conocimientos del microcon-trolador. La ventaja que presenta es que un programa escrito de este modo es mucho más rápido.La pausa más breve que se puede obtener con Arduino es de 2 microsegundos, porque se invoca con la llamada a la función delayMicroseconds() y dicha llamada requiere al-gunos ciclos de eleboración. Podéis insertar micropausas utilizando la instrucción del ensamblador nop, es decir, «ninguna operación». El microcontrolador trabajará en «no hacer nada» durante un ciclo. El mínimo retraso será de 62,5 nanosegundos. Podéis invocarlo de este modo:

asm volatile ("nop\n\t");

Para realizar pausas mayores, agregad más nop, uno a continuación de otro. Podéis encontrar más información en la dirección http://bit.ly/arduino_asm (en inglés).Una operación que os podría resultar muy útil es la posibilidad de trabajar en más de un pin a la vez. Para ello, tenéis que escribir los bits directamente en los registros. Un registro es una «cremallera» que contiene 8 bits; modificando uno solo podéis cambiar el comportamiento o el estado del pin asociado. En estos casos, no es necesario utilizar el lenguaje ensamblador, porque en el entorno de Arduino se encuentran definidas va-riables que proporcionan acceso directo a los registros. Existen tres tipos de registros:

• DDR – es el registro para configurar los pines como entradas o salidas;• PORT – es el registro para configurar el estado de los pines cuando se utilizan

como salidas, o bien para leerlo cuando se comportan como entradas;• PIN – es el registro que se utiliza para leer los pines.

Cada microcontrolador tiene más de un grupo de registros. Por ejemplo, en Arduino Uno se utilizan tres grupos de registros:

• DDRB, PORTB y PINB – para los pines digitales del 8 al 13;• DDRC, PORTC y PINC – para los pines analógicos del A0 al A5;• DDRD, PORTD y PIND – para los pines digitales del 0 al 7.

Este sería un ejemplo de uso directo de los registros:

void setup() DDRB = DDRB | B00100000;

void loop() PORTB = B00100000; delay(500); PORTB = B00000000; delay(500);

171


El sketch realiza un “blink” en el pin 13. En el setup, el bit correspondiente al pin 13 está configurado como salida. En el loop el estado del pin se modifica poniendo a 1 o a 0 el bit correspondiente.Mediante el código de nivel bajo podéis llevar a cabo algunas operaciones no accesi-bles con los comandos básicos de Arduino, y también podéis escribir el código más rápido. También existen inconvenientes: los sketch escritos así son más difíciles de leer y no son comprensibles por muchos. Otro riesgo es la no portabilidad de las ins-trucciones: un programa escrito para Arduino Uno podría ser que no funcionara en Arduino Leonardo. El sketch mostrado anteriormente, por ejemplo, no funciona con Leonardo porque el pin 13 en una placa está conectado a los registros del grupo C y en la otra, en los del grupo B.

PlanificadoresA veces, no basta con un único ciclo loop. Arduino Due es el único que permite crear varios loop a la vez e independientes, como si fueran distintos procesadores disponi-bles. Normalmente, cada una de estas funciones independientes se denomina tarea, y el control múltiple es, en realidad, una ilusión hecha realidad haciendo que el micro-procesador ejecute partes de una tarea e inmediatamente después, partes de otra.Conectad tres LED a Arduino Due en los pines 11, 12 y 13 y cargad el siguiente ejemplo:

#include <Scheduler.h>void setup() pinMode(11, OUTPUT); pinMode(12, OUTPUT); pinMode(13, OUTPUT); Scheduler.startLoop(loop2); Scheduler.startLoop(loop3);


void loop2() digitalWrite(12, HIGH); delay(500); digitalWrite(12, LOW); delay(500);vvoid loop3() digitalWrite(13, HIGH); delay(100); digitalWrite(13, LOW); delay(1000);

172


Para utilizar el planificador, debéis incluir la librería scheduler.h y definir las funciones, las cuales no aceptan parámetros y no devuelven ningún resultado, que se compor-tarán como el loop principal. En el sketch se han definido las funciones loop2 y loop3, activadas con:

Scheduler.startLoop(loop2);

Si una función necesita mucho tiempo para ser completada, es recomendable insertar una llamada a la función yield():

yield();

Esta última garantiza la ejecución también de las otras funciones “planificadas”. El método delay() ha sido modificado para que contenga una yield(): al invocar una pau-sa, el control puede pasar a otros puntos del sketch. La librería está todavía en fase de desarrollo y actualmente debe considerarse como experimental.

ContadoresEl ATmega32823 tiene en su interior tres contadores, también denominados timer, que pueden ser utilizados para desarrollar operaciones temporalizadas. Normalmente, los contadores no son accesibles mediante las instrucciones comunes de programación y para trabajar con ellos es preciso utilizar los registros. Los contadores utilizan un sis-tema de interrupciones y resultan muy cómodos de usar: una vez configurados, ya os podéis olvidar de ellos. Cuando se ejecuten, invocarán una interrupción que llamará a una función con el código que se deba ejecutar. Un contador está creado por un registro que sirve para llevar el recuento que empieza desde 0 y llega hasta un valor máximo. Los contadores están siempre en ejecución y están comandados por el reloj interno (o, si así se indica, también por un reloj externo). Dado que el reloj interno de Arduino se genera mediante un cuarzo de 16 MHz, cada paso tendrá una duración de 62,5 nanosegundos.De los tres contadores disponibles, el primero y el tercero son de 8 bits, mientras que el segundo es de 16 bits. Esto significa que los primeros son contadores que llegan a 256, mientras que el de 16 bits alcanza los 65.535.Los tres contadores son los siguientes:

• Contador0 de 8 bits, llega a un máximo de 16,4 microsegundos y es utilizado por Arduino para el funcionamiento de millis() y delay(), por lo que es mejor no usarlo;

• Contador1 de 16 bits, alcanza los 4,1 milisegundos y es utilizado por la librería para el control de servomotores;

23 Las instrucciones y los ejemplos mostrados funcionan con Arduino Uno o Mega. Otras placas po-drían usar distintos nombres para los registros: comprobad la hoja de especificaciones técnicas.

173


• Contador2 de 8 bits, llega a un máximo de 16,4 microsegundos y es utilizado por la función tone();

• Contador3, Contador4, Contador5, son de 16 bits y están disponibles solo en los ATmega1280 y 2560 (Arduino Mega).

Cuando un contador llega a su valor máximo, es posible controlar su estado leyendo un flag, o bien generando una interrupción que puede ser utilizada para llevar a cabo operaciones de tiempos muy precisos. La interrupción resetea el flag automáticamente.Los contadores están precedidos por un prescaler, un circuito que funciona de forma parecida a un multiplicador y es útil para aumentar la escala o el valor máximo del contador. El prescaler puede ser configurado solo con valores predeterminados: 1:1, 1:8, 1:64, 1:256 y 1:1024. Situando el prescaler a 1024, es posible ampliar la duración de los contadores hasta 4,19 segundos (en el caso del Contador2).Antes de utilizar los contadores, es preciso configurarlos, ajustando correctamente cada bit en cada registro. Todos los contadores tienen dos registros para las configu-raciones, denominados TTCR (Timer/Counter Control Registers). Existen en total tres pares de registros: TTCR0A y TTCR0B, TTCR1A y TTCR1B, TTCR2A y TTCR2B.Los tres últimos bits CS12, CS11 y CS10 del registro TTCRxB sirven para configurar el prescaler.

Tabla 7.2 - Configuración de los flags para el prescaler.

CS12 CS11 CS10 Descripción

0 0 0 contador en reposo0 0 1 multiplicador 1 (prescaler deshabilitado)0 1 0 multiplicador 80 1 1 multiplicador 641 0 0 multiplicador 2561 0 1 multiplicador 1024

Para configurar el prescaler a 1024 es preciso escribir:

TCCR1B = 0b00000101;

O bien, en hexadecimal:

TCCR1B = 0x05;

El registro TIMSK sirve para definir qué tipo de interrupción generará el contador una vez alcanzado el final del recuento. El comportamiento se configura modificando los

174


bits del registro. El primer bit sirve para activar una interrupción en el caso en que se alcance el valor máximo (overflow). Para configurarlo, basta con escribir lo siguiente:

TIMSK1 = 0b00000001;

O bien, en hexadecimal:

TIMSK1 = 0x01;

El recuento se mantiene en el registro TCNT que será de 8 o 16 bits. Antes de configu-rar un contador, se recomienda reajustar el registro. El registro para el Contador1 tiene 16 bits, por lo que el número hexadecimal tiene cuatro ceros:

TCNT1 = 0x0000;

La función que llama al contador en caso de overflow no puede ser definida de forma personalizada, sino que tiene un nombre y un aspecto particulares:

ISR(TIMER1_OVF_vect) //aquí vuestro código

Este sería un ejemplo completo para hacer parpadear el LED en el pin 13 unos 4 segundos:

volatile int tick = 0;

void setup() Serial.begin(9600); pinMode(13, OUTPUT);

cli();

TCCR1A = 0x00; // prescaler a 1:1024 TCCR1B = 0b00000101; //reset del contador TCNT1=0x0000; //habilita la interrupción TIMSK1=0x01; sei();

int stato = LOW;

void loop() if (tick == 1) tick = 0; estado = !estado; digitalWrite(13, estado);

175


//Contador1 Overflow interrupción.ISR(TIMER1_OVF_vect) if(tick == 0) tick = 1;

El setup presenta dos nuevas funciones, cli() y sei(), que sirven para deshabilitar glo-balmente las interrupciones y para rehabilitarlas, lo que permite ciertas configuracio-nes bastante delicadas en los registros. Después, los registros se reajustan, el prescaler se configura a 1024 y se habilita la llamada a la interrupción: hasta aquí todo debería estar bastante claro. La interrupción se gestiona en el método ISR(TIME_OVF_vect), que podéis utilizar para insertar vuestro código. En este caso, la llamada modifica el estado de la variable volátil tick, que se examina en el loop para modificar el estado del LED en el pin 13.Los contadores ofrecen intervalos bastante “cuadrados” y en ocasiones es difícil con-figurar correctamente los tiempos. Para conseguir una mayor flexibilidad, es posible intentar conseguir que el recuento desencadene la interrupción no del fondo de la escala sino de un valor indicado por vosotros. Esta técnica de uso se denomina Clear Timer on Compare Match (CTC). Para configurar una temporización determinada, es preciso calcular el número de disparos necesarios para llegar al tiempo deseado:

número_disparos = tiempo_deseado / (tiempo_para_un_paso)

A este número de disparos, tendremos que restarle una unidad porque, cuando se al-cance el valor configurado, el contador se reseteará y la operación solicitará el tiempo de un tick, que se calcula teniendo en cuenta el prescaler. El valor que se debe alcanzar se ajusta, en formato hexadecimal, en el registro OCRxA:

OCR1A = 0x0A00;

La modalidad CTC se activa configurando a 1 el cuarto bit del registro TCCRxB. Se ha uti-lizado el operador |= para no reajustar las otras configuraciones presentes en el registro.

TCCR1B |= 0b00001000;

Por último, se habilita la interrupción de comparación en el registro TIMSKx:

TIMSK1 = 0b00000010;

La interrupción llamará al método “especial” ISR(TIMER1_COMPA_vect), en cuyo interior podréis ubicar las instrucciones que se deben ejecutar al finalizar el recuento.

176


Este es el código completo:

volatile int tick = 0;


cli();

TCCR1A = 0x00; //prescaler TCCR1B = 0b00000100; //recuento a alcanzar OCR1A = 0x0A00;

//CTC mode: 1 sobre el cuarto bit del registro: 0b 0000 1000 //TCCR1B |= (1 << WGM12); TCCR1B |= 0b00001000;

//habilita la interrupción //TIMSK1 |= (1 << OCIE1A); TIMSK1 = 0b00000010; sei();

int stato = LOW;

void loop() if (tick == 1) tick = 0; estado = !estaado; digitalWrite(13, estado);

ISR(TIMER1_COMPA_vect) if(tick == 0) tick = 1;

Otro tipo de contador especial es el watchdog timer, un contador independiente alimen-tado por un reloj a 128 kHz, siempre activo. Este contador puede utilizarse para desper-tar a la placa cuando se encuentra en hibernación profunda, o para identificar situacio-nes de reposo o bloqueo del sketch y, por tanto, resetear automáticamente la placa. El watchdog está controlado por dos registros especiales y puede llegar a temporizaciones de hasta 8 segundos. Este contador también está precedido por un prescaler.Los dos registros son:

• WDTCSR – Watchdog Timer Control Register, utilizado para configurar los in-tervalos y la modalidad de funcionamiento;

• MCUSR – MCU Status Register, que indica por qué se ha llevado a cabo un reset y normalmente es examinado cuando finaliza el watchdog.

177


El prescaler se ajusta configurando los bits WDP0, WDP1, WDP2, WDP3 del registro WDTCSR. Cuando los bits están todos a 0, el contador se regula a 16 milisegundos. El máximo valor se consigue configurando 1001, que corresponde a un tiempo de 8 segundos.El comportamiento del watchdog se configura ajustando los bits WDTON, WDE y WDIE, como se muestra en la tabla siguiente.

Tabla 7.3 - Configuración de los flags para el watchdog.

WDTON WDE WDIE Modo Acción

1 0 0 deshabilitado ninguna1 0 1 interrupción interrupción1 1 0 reset del sistema reset1 1 1 interrupción y reset del sistema interrupción y reset0 cualquier cualquier reset del sistema reset

Así, el watchdog puede comportarse de distintas maneras:• generar una interrupción que puede despertar al microcontrolador en fase de

reposo (profundo);• resetear el microcontrolador cuando se encuentra bloqueado;• generar una interrupción y después un reset.

Los flags del watchdog se configuran de un modo preciso siguiendo una secuencia que garantice el desarrollo de las operaciones en poco tiempo. Este es un ejemplo de secuencia de configuración:

//reajusta el flag de resetMCUSR &= ~(1<<WDRF); //Activa la modalidad de cambio de los registros (¡disponible solo durante los próximos 4 ciclos de reloj! )WDTCSR |= (1<<WDCE) | (1<<WDE);

//configura el prescaler a 8 segundosWDTCSR = 1<<WDP0 | 1<<WDP3; //Habilita el modo con interrupciónWDTCSR |= _BV(WDIE);

La escritura parece un poco críptica, pero para modificar los registros se debe realizar una solicitud explícita cambiando un flag especial (WDCE y WDE), y después se de-ben aportar las modificaciones dentro de cuatro ciclos de reloj. Los flags se configuran utilizando máscaras disponibles en la librería wdt.h, la cual debe incluirse al inicio del sketch.

178


Modo de reposo y ahorro energéticoUn aspecto importante en un circuito alimentado con batería es la gestión de la co-rriente: cuanto menos consumáis, más duradero será su funcionamiento. Normal-mente, un microcontrolador como Arduino consume algunas decenas de miliampe-rios (sobre unos treinta), lo que, si se alimenta con una batería de 9 V (tiene una capacidad de unos 600 mA/h), permite que el circuito funcione unas 600 / 30 = 20 horas. En realidad, el circuito funcionará menos de 20 horas, porque la descarga de la batería no es constante y, a un cierto punto, se producirá una disminución de las prestaciones.Escribiendo las instrucciones precisas, se pueden desactivar módulos internos del mi-crocontrolador y reducir al mínimo el consumo de corriente. Es posible pasar de algu-nas decenas de miliamperios a pocos miliamperios: que son realmente pocos y pueden mantener con vida vuestro circuito durante meses con una sencilla batería. Una vez elegidos los módulos que se van a desactivar y llamados los métodos para suspender la actividad del chip, se necesita un determinado evento para desencadenar el desper-tar. Existen cuatro casos:

• un evento electrónico externo vinculado a una interrupción, como la pulsación de un botón o la llegada de una señal eléctrica a un pin;

• un contador interno que periódicamente despierta a la placa;• una señal procedente de la línea de serie;• el watchdog timer que puede ejecutar operaciones y volver al modo de reposo.

Arduino Uno cuenta con un regulador de tensión que cuando se utiliza consume siem-pre corriente (como mínimo unas decenas de miliamperios). Para utilizar la solución del ahorro energético, es necesario alimentar Arduino sobrepasando la sección de ali-mentación. Debéis tener en cuenta que en la placa hay un chip para la comunicación por USB que consume corriente constantemente.Para aumentar la duración del circuito, podéis actuar de tres modos distintos:

• conectando una batería de mayor capacidad (si tenéis espacio suficiente);• añadiendo dispositivos para recargar la batería actual (como paneles solares);• utilizando un simple microcontrolador ATmega328 (o similar).

Incluyendo las librerías sleep.h y power.h, podéis poner en reposo Arduino eligiendo qué partes desactivar. Es posible elegir entre cinco modalidades de ahorro energético, que se muestra a continuación por orden de profundidad del modo de reposo:

• SLEEP_MODE_IDLE;• SLEEP_MODE_ADC;• SLEEP_MODE_PWR_SAVE;• SLEEP_MODE_STANDBY;• SLEEP_MODE_PWR_DOWN.

179


Al activar una de estas modalidades de funcionamiento, apagaréis algunos módulos internos del microcontrolador reduciendo el consumo de corriente de forma incluso drástica. Si el despertar se ha confiado a un hardware externo, es necesario garantizar que este hardware sea alimentado para poder producir las señales necesarias.Los pasos que hay que seguir para poner en reposo el microcontroaldor son:

• incluir las librerías sleep.h y power.h en el sketch;• elegir el mecanismo que despertará el chip;• configurar el método de reposo con set_sleep_mode(modo_de_reposo);• habilitar el reposo con sleep_enable();• activar el reposo con sleep_mode();• desactivar el reposo con sleep_disable().

Veamos un ejemplo con Arduino Uno y un botón. Los terminales del botón están co-nectados al GND y al pin número 2, como se indica en la Figura 7.1.

Figura 7.1 - Conexión de un botón al pin 2 para despertar el circuito.

Para empezar, es necesario incluir las librerías para la gestión del reposo y de la po-tencia:

#include <avr/sleep.h>#include <avr/power.h>

180


Después, se debe escribir la función para despertar del estado de hibernación. La fun-ción desactivará la interrupción configurada en el pin número 2 y encenderá el LED en el pin 13; podemos nombrarlo como más nos guste:

void pin2Interrupt(void) detachInterrupt(digitalPinToInterrupt(2)); digitalWrite(13, HIGH);

Para activar el modo de reposo, se necesita una secuencia de operaciones que, para mayor claridad, es mejor recoger en una función. La primera operación es la de activar una interrupción en el pin 2 y conectarla a la función para despertar a Arduino, que hemos denominado pin2Interrupt:

attachInterrupt(digitalPinToInterrupt(2), pin2Interrupt, LOW);

Para este ejemplo, configuramos el máximo ahorro energético utilizando:

set_sleep_mode(SLEEP_MODE_PWR_DOWN);

Las operaciones de configuración finalizan habilitando el modo de reposo y activándolo:

sleep_enable(); sleep_mode();

Es muy importante disponer de un mecanismo despertador antes de invocar a sleep_mode, si no, el circuito ya no se sobrepondrá (sencillamente tendréis que reprogramar-lo). La ejecución del programa se interrumpirá inmediatamente después de la llamada a sleep_mode() y se retomará en el mismo instante en que llegue la señal para desper-tarse, que en este caso es la pulsación del botón. Lo primero que hay que hacer cuando el programa se reactiva es deshabilitar el modo de reposo:

sleep_disable();

En el setup, el pin 2 está configurado como INPUT_PULLUP, de manera que no sea nece-sario añadir una resistencia al botón; el pin 13 se utiliza como salida para usar el LED como marcador visual del estado de la placa:

void setup() Serial.begin(9600); pinMode(2, INPUT_PULLUP); pinMode(13, OUTPUT); Serial.println("Setup: ok");


181


En el loop, una variable segundos se incrementa cada segundo y, cuando vale 3, activa el procedimiento de reposo.Este es el sketch completo:


void pin2Interrupt(void) detachInterrupt(digitalPinToInterrupt(2)); digitalWrite(13, HIGH);

void enterSleep(void) attachInterrupt(digitalPinToInterrupt(2), pin2Interrupt, LOW); delay(100); digitalWrite(13, LOW); set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); sleep_mode(); /* El programa se reanuda aquí. */ sleep_disable();

void setup() Serial.begin(9600); pinMode(2, INPUT_PULLUP); pinMode(13, OUTPUT); Serial.println("Setup: ok");


int segundos=0;void loop() delay(1000); segundos++; Serial.print("Activo desde "); Serial.print(segundos, DEC); Serial.println(" s."); if(segundos == 3) Serial.println("¡Reposo"); delay(200); segundos = 0; enterSleep();

182


También es posible despertar el circuito utilizando una señal procedente del puerto serie. El sketch es el mismo del ejemplo anterior; el circuito se modifica conectando la línea de recepción del ATmega (situada en el pin 0) al pin 2 con una resistencia de 220 ohms. También se utiliza la interrupción conectada al pin 2 para despertar al chip en cuanto lle-ga un dato por el puerto serie. Cargad el sketch, abrid el Serial Monitor y, cuando el circui-to se ponga en modo de reposo, enviáis un carácter por el puerto serie para reactivarlo.

Figura 7.2 - Cómo conectar una resistencia para despertar a Arduino utilizando el puerto serie.

Es posible utilizar los contadores para gestionar el ahorro energético. Podéis conectar el despertador a una interrupción interna generada por el contador. Configurad el con-tador a unos 4 segundos usando un prescaler configurado con el valor 1024. Cuando el LED cambie de estado, que ocurre en el loop, se invoca el método enterSleep() donde es preciso especificar qué módulos del microcontrolador deshabilitar. Como podréis observar, falta la instrucción para apagar el Contador1. Cuando llegue la interrupción generada por el contador, el chip se despertará. En este caso, aunque el LED esté en-cendido, el resto del microcontrolador está inactivo.

183



volatile int timer = 0;


//setup del timer TCCR1A = 0x00; TCNT1=0x0000; //prescaler a 1024 TCCR1B = 0x05; //interrupción en overflow TIMSK1=0x01;

int estado = LOW;

void loop() if(timer == 1) timer = 0; estado = !estado; digitalWrite(13, estado); //activa el modo de reposo enterSleep();

ISR(TIMER1_OVF_vect) if(timer == 0) timer = 1;

void enterSleep(void) set_sleep_mode(SLEEP_MODE_IDLE); sleep_enable();

//deshabilita los periféricos power_adc_disable(); power_spi_disable(); power_timer0_disable(); power_timer2_disable(); power_twi_disable();

sleep_mode();

//se reanudará dentro de... sleep_disable(); //habilita los periféricos del microcontrolador power_all_enable();

184


Un método todavía más eficaz consiste en utilizar el watchdog del ATmega, que no se pone nunca en suspensión. Este es un sketch para la suspensión en SLEEP_MODE_PWR_DOWN. El despertar se activa con la interrupción generada por el watchdog, ISR(WDT_vect).

#include <avr/sleep.h>#include <avr/power.h>#include <avr/wdt.h>

volatile int watchdog = 1;

void setup() pinMode(13,OUTPUT); MCUSR &= ~(1<<WDRF); WDTCSR |= (1<<WDCE) | (1<<WDE); //prescaler a 4 secondi WDTCSR = 0<<WDP0 | 1<<WDP3; //modo: interrupción WDTCSR |= _BV(WDIE);

int estado = LOW;

void loop() if(watchdog == 1) estado = !estado; digitalWrite(13, estado); watchdog = 0; enterSleep();

ISR(WDT_vect) if(watchdog == 0) watchdog = 1;

void enterSleep(void) set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); sleep_mode();

//reanuda aquí tras el reposo sleep_disable(); power_all_enable();

Arduino como teclado o ratónLas placas Arduino que utilizan el chip ATmega32u4 (Leonardo, Due y Zero) pueden utilizarse como si fueran un ratón o un teclado. Utilizando librerías proporcionadas por Arduino, al conectar la placa al ordenador, esta será reconocida como un ratón

185


o un teclado y podréis utilizarla para emular estos dispositivos y ubicar el ratón en la pantalla, o bien para enviar caracteres.Aunque este uso es muy sencillo, conviene ir con cuidado: el mecanismo debe ser siempre desactivable, si no ya no podréis volver a programar vuestra placa.Para simular el envío de caracteres desde el teclado, antes debéis incluir la librería Keyboard.h.

#include <Keyboard.h>

En algún punto de vuestro sketch, activad la sesión para el envío de las teclas con Key-board.begin(), después enviad los caracteres con print() y, por último, cerrad la sesión.

Keyboard.begin();Keyboard.print("Hello Keyboard!");Keyboard.end();

¡Cuidado! No escribáis nunca algo de este estilo:


void setup() Keyboard.begin(); Keyboard.print("Hello Keyboard!"); Keyboard.end();

void loop()

Con este sketch, al iniciar Arduino, este se convertirá en un teclado y no podréis volver a programarlo nunca más. Para recuperarlo, necesitaréis una clave ISP especial con la cual cargar un sketch vacío y, eventualmente, el bootloader.Cuando activéis la modalidad de teclado (o ratón) siempre debéis tener la posibilidad de retomar el control. Podéis hacerlo activando estas funciones solo después de la pulsación de una tecla. Conectad un botón entre el pin 2 de Arduino y el GND y cargad este sketch:


void setup() pinMode(2, INPUT_PULLUP);

void loop() if (digitalRead(2)) Keyboard.begin(); Keyboard.print("Hello Keyboard!"); Keyboard.end();

186


De este modo, la placa será reconocida como teclado solo al pulsar el botón. Para pro-bar el sketch, después de su carga, desconectáis Arduino del ordenador, abrís un edi-tor de texto y hacéis clic en el área de escritura; después, volvéis a conectar Arduino y pulsáis el botón. El texto “Hello Keyboard” aparecerá en el editor (véase la Figura 7.3).

Figura 7.3 - Tras haber programado Arduino Leonardo como si fuera un teclado, es posible escribir caracteres en un editor.

Con la librería, no es posible escribir todos los caracteres, sino solo aquellos que for-man parte de un teclado real. Existen algunas teclas especiales y modificadores para crear composiciones de caracteres (por ejemplo, CTRL, SHIFT, ALT, etc.).

Tabla 7.4 - Teclas especiales utilizados por la librería Keyboard.

Tecla Valor

KEY_LEFT_CTRL 0x80 KEY_LEFT_SHIFT 0x81

KEY_LEFT_ALT 0x82 KEY_LEFT_GUI 0x83

KEY_RIGHT_CTRL 0x84 KEY_RIGHT_SHIFT 0x85

KEY_RIGHT_ALT 0x86 KEY_RIGHT_GUI 0x87 KEY_UP_ARROW 0xDA

187


Tecla Valor

KEY_DOWN_ARROW 0xD9 KEY_LEFT_ARROW 0xD8

KEY_RIGHT_ARROW 0xD7 KEY_BACKSPACE 0xB2

KEY_TAB 0xB3 KEY_RETURN 0xB0

KEY_ESC 0xB1 KEY_INSERT 0xD1 KEY_DELETE 0xD4

KEY_PAGE_UP 0xD3 KEY_PAGE_DOWN 0xD6

KEY_HOME 0xD2 KEY_END 0xD5

KEY_CAPS_LOCK 0xC1 KEY_F1 0xC2 KEY_F2 0xC3 KEY_F3 0xC4 KEY_F4 0xC5 KEY_F5 0xC6 KEY_F6 0xC7 KEY_F7 0xC8 KEY_F8 0xC9 KEY_F9 0xCA KEY_F10 0xCB KEY_F11 0xCC KEY_F12 0xCD

Para crear composiciones de teclas, se utiliza el método Keyboard.press() para agregar caracteres uno tras otro. Llamar a press() equivale a apoyar un dedo en el teclado; para soltarlo, debéis llamar a releaseAll(). Para escribir una letra A en mayúsculas, podéis escribir:

Keyboard.press(KEY_LEFT_SHIFT);Keyboard.press('a');delay(100);Keyboard.releaseAll();

La función release() se utiliza para soltar una única tecla.

188


Para la gestión del ratón existe una librería denominada mouse.h que se incluye al inicio del sketch:

#include <Mouse.h>

Una sesión de emulación del ratón empieza con la llamada al método begin() y termi-na con end(). El ratón se puede desplazar utilizando Mouse.move(). Los movimientos son siempre relativos a la posición actual del ratón. El método move() supone tres paráme-tros: el desplazamiento horizontal, el desplazamiento vertical y la posible rotación de la rueda del ratón.

Mouse.begin();Mouse.move(100,100,0);Mouse.end();

Se pueden aplicar al ratón las mismas advertencias que se han indicado para el tecla-do: si no contáis con un método para habilitar este comportamiento “bajo demanda”, corréis el riesgo de no poder volver a programar la placa nunca más.Aquí tenéis un sencillo ejemplo para simular el movimiento del rató. El comportamien-to se activa con la pulsación de un botón conectado entre el pin número 2 y el GND.

#include <Mouse.h>

void setup() pinMode(2, INPUT_PULLUP);

void loop() if (digitalRead(2)) Mouse.begin(); Mouse.move(100,100,0); Mouse.end();

Para enviar un clic, debéis utilizar:

Mouse.clic();

que corresponde a un clic con el botón izquierdo. Podéis especificar el botón pulsado con:

Mouse.clic(botón);

donde botón puede asumir los siguientes valores: MOUSE_LEFT, MOUSE_RIGHT, MOUSE_MIDDLE.También podéis activar un botón y mantenerlo pulsado mediante:

Mouse.press();

189


O bien:

Mouse.press(botón);

Para soltar el botón utilizad el método release(). Con estos métodos podéis realizar también movimientos complejos, como arrastrar y soltar.

analogReferenceLa función analogReference sirve para modificar la tensión de referencia que se debe utilizar con las entradas analógicas que normalmente trabajan entre 0 y 5 V. Las lec-turas dentro del rango de 5 V, o 5000 milivoltios, se transforman en un número que puede asumir un valor máximo de 1023. La conversión es realizada por un circuito convertidor analógico-digital, que compara la tensión aplicada a las entradas analó-gicas con la máxima tensión de referencia y determina el número entero que hay que devolver. Una unidad corresponde a unos 5 milivoltios. En alguna ocasión, es posible que tengáis que conectar un sensor analógico que funciona en un intervalo de tensión más limitado. Algunos acelerómetros analógicos trabajan a 3,3 V y, en estos casos, se perderían todos los valores hasta 5 V. Para utilizar todo el intervalo de valores, sería oportuno modificar la gama de tensiones convertibles por la analogRead pasando el valor máximo de 5 a 3,3 V. Esto es posible aplicando 3,3 V a la entrada AREF e indi-cando a Arduino que ya no queremos utilizar la referencia de tensión externa, con la instrucción:

analogReference(EXTERNAL);

Los parámetros que se pueden utilizar con Arduino son:• DEFAULT – usa la tensión interna de la placa a 5 V;• EXTERNAL – la referencia se encuentra en el pin AREF;• INTERNAL – utiliza una referencia de 1,1 V.

Conectando una tensión de referencia a AREF, es preciso prestar mucha atención a no aplicar tensiones negativas o superiores a 5 V: podrías dañar a Arduino.

Al aplicar una tensión en AREF, prestad mucha atención a no llevar a cabo ninguna lec-tura analógica con analogRead antes de invocar a analogReference. También en este caso corremos el riesgo de crear un cortocircuito y dañar a Arduino. Para evitar problemas, intentad poner siempre esta configuración en el setup del sketch y esperad unos cien milisegundos antes de leer alguna de las entradas analógicas, porque los circuitos deben estabilizarse.

190


El bootloaderPara programar un microcontrolador genérico, se necesita un kit de programación que normalmente contiene una placa de programación en la cual se aplica el chip virgen y un programador que, conectado a un ordenador, escribe las instrucciones en la memoria del chip. En cambio, Arduino se programa con un simple cable USB porque le ha sido precargado un pequeño programa denominado bootloader, que se ocupa de su progra-mación. El bootloader, o gestor de arranque, se inicia cuando se enciende la placa y com-prueba que desde el puerto USB está llegando un nuevo firmware: en caso afirmativo, lo transcribe en la memoria flash, y si no, termina y deja el control al firmware cargado.

El bootloader simplifica mucho la vida de los programadores de firmware, pero ocupa de forma permanente un pqueño espacio en la memoria del microcontrolador (unos 2 kB).

A veces podría ocurrir que, debido a algún error o una fatal coincidencia, vuestro Arduino ya no se pueda volver a programar y el bootloader ya no se pueda volver a usar. Podéis in-tentar reprogramarlo directamente desde el entorno de desarrollo de Arduino, pero nece-sitaréis un programador. Podéis comprar uno en Internet por menos de diez euros: existen de varios tipos, denominados AVRISP Programmer, así como una versión open source, la FabISP, realizada en el Fab Lab del MIT. También podríais construirlo, pero necesitaréis un amigo que tenga uno para que os lo deje y poder programar el vuestro. Las instrucciones para crear un FabISP se encuentran en el sitio del MIT (http://bit.ly/makefabisp). Ade-más, es posible transformar una placa Arduino Uno en un ISP Programmer: encontraréis el sketch entre los ejemplos proporcionados, con el nombre de ArduinoISP.En todas las placas Arduino, podéis ver uno o más grupos de pines (2x3 header pin) con el texto “ICSP” (In Circuit Serial Programming). Conectando el programador a es-tos pines podréis cargar directamente el firmware en el microcontrolador y, en casos extremos, restaurar el bootloader. En Arduino Uno encontraréis dos conectores ICSP: uno se encuentra situado junto al conector USB y sirve para reprogramar el chip de control del puerto; el otro muestra el texto “ICSP” y está conectado al ATmega328.Los seis pines forman un puerto SPI (Serial Peripheral Interface), con seis líneas:

• V+ – una línea de alimentación para el dispositivo a programar;• GND – la línea común a 0 V;• MISO – Master Input Slave Output;• MOSI – Master Output Slave Input;• SCK – el reloj de serie para la sincronización de la transmisión;• RESET – utilizado como Chip Select para habilitar la comunicación con el dis-

positivo receptor.

191


Estos puertos son muy importantes porque, habitualmente, los chips no se programan antes de ser soldados a las placas, sobre todo los de formato SMD. Para programar “di-rectamente” el microcontrolador incluido en la placa de Arduino, debéis conectar vues-tro programador a estos pines, con mucho cuidado de no equivocaros. Utilizad un cable de seis polos con conectores hembra 2x3, o bien cables jumper de tipo hembra-hem-bra. Si queréis utilizar Arduino Uno como programador ISP, en primer lugar cargadle el sketch ArduinoISP que encontraréis entre los ejemplos proporcionados con el IDE y, después, conectadlo al chip o a la placa. Una vez descargado el sketch, encontraréis:

• MOSI en el pin 11 de Arduino;• MISO en el pin 12;• SCK en el pin 13;• RESET en el pin 10.

Prestad especial atención al pin con los 5 V: no lo conectéis nunca para alimentar pla-cas que funcionan a 3 V (por ejemplo, Arduino Due) o lo dañaréis irreparablemente.

Figura 7.4 - ArduinoISP conectado a una placa Arduino Uno para la programación.

El procedimiento de carga del bootloader se puede realizar utilizando Arduino IDE:• abrís el programa;• seleccionáis la placa correcta en Tools > Boards;• configuráis el programador en Tools > Programmer. Generalmente, veréis

AVRISP mkII; elegid el programador adecuado, por ejemplo, ArduinoISP;• si habéis elegido ArduinoISP, configurad también el puerto serie de comunicación;

192


• elegís Tools > Burn Bootloader para transferir el bootloader a la placa conectada al programador.

Si el procedimiento descrito no funciona, utilizad el programa avrdude (para todas las plataformas) y cargad manualmente el bootloader, configurando correctamente los fu-ses, es decir, los flags especiales para la configuración de los microcontroladores AVR.

Programar los chips AVRAhora que ya os habéis familiarizado bastante con Arduino, podéis intentar programar directamente chips individuales en lugar de una placa de desarrollo: conseguiréis cir-cuitos más pequeños y también económicos. Un chip ATtiny, una versión reducida de Arduino, cuesta muy poco dinero.Los chips Atmel son sencillos de programar utilizando un lápiz ISP o Arduino Uno con el sketch ArduinoISP cargado. Los AVR producidos desde 1996 hasta ahora son muchos: desde los pequeños ATtiny13, ATtiny85, ATtiny45, ATtiny2313 (que dispo-ne también de un puerto serie), hasta los más potentes ATmega328, ATmega644, ATmega1284 y ATmega2560.

Tabla 7.5 - Características de algunos chips AVR.

AVR PinFlash(kB)

RAM(B)

EEPROM(B)

Frecuencia máxima(MHz)

ATtiny25 8 2 128 128 20ATtiny45 8 4 256 256 20ATtiny85 8 8 512 512 20

ATtiny2313 20 2 128 128 20ATmega328 32 32 2048 1024 20

ATmega644P 40 64 4096 2048 20ATmega2560 100 256 8192 4096 20

Figura 7.5 - Pinouts de los microcontroladores ATtiny25, 45 y 85.

193


Para programar los chips ATtiny o ATmega, el programador ISP se debe conectar a las líneas SPI: MOSI, MISO, SCK (o UCK), RESET y las alimentaciones VCC y GND.Cada microcontrolador, además de sus memorias internas (RAM, EEPROM y flash), dispone de algunos bytes reservados (denominados también “registros”) que sirven para configurar su comportamiento. Estos registros se denominan fuses y se pueden modificar libremente con el programador ISP. Para la escritura de los fuses se utilizan programas como avrdude (de terminal) o WinAVR para la plataforma Windows. Los fuses son secuencias de bits que se pueden calcular siguiendo las instrucciones con-tenidas en las hojas de especificaciones técnicas online, como FuseCalc (http://www.engbedded.com/fusecalc/).Los AVR tienen 3 bytes destinados a los fuses. Los principales parámetros son:

• Clock Selection – todas las CPU necesitan un reloj para funcionar. El reloj es una onda cuadrada, regular y precisa, que marca el ritmo de las operaciones. El reloj puede proceder de una fuente externa (external clock), o bien puede ser genera-do dentro del chip (internal clock). El reloj interno no es demasiado preciso y su frecuencia podría depender de la tensión de alimentación y de la temperatura. Si la precisión no es fundamental, al elegir el reloj interno nos ahorramos dos pinouts porque no tenemos que conectar ningún componente al chip. El reloj interno puede ser configurado a 8 MHz, 4 MHz o 128 kHz. Las configuracio-nes de fábrica incluyen un reloj interno de 8 MHz. Si elegimos el reloj externo, debemos conectar un componente adicional, como un cristal de cuarzo o un resonador cerámico, que ocupará dos pines. Con un cristal de cuarzo, el reloj puede llegar hasta los 20 MHz;

• Startup Time – es el intervalo de tiempo que el chip esperará antes de ejecu-tar el firmware. Es preciso esperar un cierto número de milisegundos antes de que la señal del reloj sea estable y precisa. Es mejor esperar al máximo (14 Ck + 65 ms = 14 golpes de reloj y 65 milisegundos);

• Clock Output – la señal del reloj puede llevarse también fuera del chip. Esto es útil si queremos sincronizar más chips. Si activáis esta opción (desactivada por defecto), el reloj aparecerá en uno de los pines (el pin D2 en el ATtiny85);

• Clock Divide – activando esta opción, la frecuencia del reloj se dividirá entre ocho. Suele estar activa, por lo que los chips giran a una velocidad efectiva de 1 MHz;

• Reset Disable – ¡esta opción no se debe seleccionar nunca! Si lo hacéis, el chip no se podrá volver a programar nunca más, porque desactiva el pin RESET y lo transforma en un pin adicional;

194


Brown-out Detect (BOD) – es una opción deshabilitada por defecto pero, en cambio, muy útil. De hecho, activa una protección que interviene si la tensión de alimentación disminuye y el chip no recibe potencia. En esta situación, el microcontrolador empe-zará a comportarse de un modo anómalo, leyendo y escribiendo al azar la memoria flash. Si el brown-out está activo, cuando la alimentación baja por debajo de un cierto valor, el chip se desactiva hasta que la tensión vuelva a ser la adecuada. Para un chip alimentado a 5 V, la tensión de brown-out se puede configurar a 4,3 V.

ATtiny85Para programar un chip ATtiny se puede utilizar el entorno de desarrollo de Arduino y una placa Arduino Uno configurada como programador ISP. En primer lugar, es preciso conseguir un ATtiny85 o 45. Estos chips se pueden adquirir en los grandes distribui-dores de componentes, como RS o Farnell, y tienen un precio muy bajo respecto a una placa Arduino; de hecho, los ATtiny tienen pocos pines y menores capacidades. El firmware que se puede cargar en este tipo de chips no puede ser muy grande, porque estos tienen un cuarto del espacio disponible en los chips ATmega328. En el caso en que un ATtiny no sea suficiente, se puede utilizar también un chip ATmega.El ATtiny85 tiene solo ocho pines, de los cuales dos se utilizan para la alimentación y uno, para el RESET. Quedan solo cinco pines que se pueden utilizar como entradas o salidas digitales. Dos de estos cinco pines pueden generar señales PWM y tres pue-den ser utilizados como entradas analógicas. La tensión de alimentación debe estar entre 2,7 y 5,5 V. Si se superan los 5,5 V, el chip se quema. La Tabla 7.6 muestra los pines físicos, el número “lógico” del pin que se debe utilizar en el sketch y la función del pin.

Tabla 7.6 - Funciones de los pines del ATtiny85.

Pin del chip

FunciónNúmero del pin

digitalNúmero del pin

analógico

1 RESET2 Digital/Analog Input 3 33 Digital/Analog Input 4 24 GND5 Digital/Analog Input/PWM 06 Digital/Analog Input/PWM 17 Digital/Analog Input/PWM 2 18 VCC (+5V)

195


Programar el ATtiny85 con la última versión de Arduino (> 1.6.4) es muy fácil. Antes era necesario descargar un parche para añadirlo al programa, pero actualmente basta con seguir este procedimiento:

• iniciar Arduino IDE;• abrir el panel de preferencias;• en el campo Additional Boards Manager URLs insertar esta dirección: https://

raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/packa-ge_damellis_attiny_index.json;

• guardar las preferencias pulsando en OK;• desplegar el menú Tools > Boards y seleccionar la opción Board Manager;• en la ventana que se abre, buscar la opción ATtiny by David A. Mellis;• pulsar sobre ella y hacer clic en Install;• al final del proceso, en las Boards del menú Tools > Board, tendría que aparecer

la nueva opción attiny.

Una vez el IDE está configurado, podéis programar vuestro primer chip. Necesitaréis:• una placa Arduino UNO con el sketch ArduinoISP ya cargado;• un chip AVR ATtiny85 de Atmel;• un condensador de 10 microfaradios;• un LED;• una resistencia de 220 ohms;• una breadboard;• cables o jumpers.

Y así es como debéis proceder:• iniciad el IDE de Arduino;• acoplad la Board sobre el attiny85;• seleccionad vuestro sistema de programación en el menú Tools > Program-

mers. Si utilizáis Arduino, elegid ArduinoISP;• copiad el sketch que se muestra a continuación;

//Blink per ATtiny85//el pin 0 es en realidad el pin número 5 del chipvoid setup() pinMode(0, OUTPUT);

void loop() digitalWrite(0, HIGH); // enciendo el LED delay(1000); // espero un segundo digitalWrite(0, LOW); // apago el LED delay(1000); // espero un segundo y después repito el loop

196


• conectad Arduino al ordenador con un cable USB y comprobad que el puerto serie está configurado correctamente;

• generad el circuito ilustrado en la Figura 7.6, colocando el ATtiny en una bread-board y conectando Arduino a sus pines de programación;

Figura 7.6 - Conexión de un ATtiny85 para la programación con ArduinoISP.

• conectad las tomas GND y 5V de Arduino al ATtiny, para proporcionarle ali-mentación;

• insertad un condensador de 10 microfaradios en los pines RESET y GND de Arduino. El terminal positivo del condensador se conecta al RESET;

• compilad el sketch y transferidlo a la placa pulsando el botón Verify y, después, Upload;

• desconectad Arduino del ordenador, para que el ATtiny ya no tenga alimentación;• extraed los cables utilizados para la programación (pines 10, 11, 12 y 13), pero no

los jumpers utilizados para la alimentación (GND y 5V);• insertad el LED y una resistencia de 220 ohms al pin físico número 5 del chip

(véase la Figura 7.7); • volved a conectar Arduino al ordenador mediante el cable USB. Arduino será

utilizado solo para alimentar el ATtiny;• el LED parpadeará.

197


Figura 7.7 - El ATtiny85 conectado a un LED y alimentado por Arduino.

Si algo va mal, el LED no parpadeará y, probablemente, en un recuadro del IDE de Ar-duino aparecerán unos textos de color naranja. En tal caso:

• comprobad si habéis cometido algún error al teclear el código. Analizando los mensajes de color naranja, podréis extraer alguna información sobre el tipo de error y su posición dentro del sketch;

• si entre los mensajes de error se encuentra el código SK500, es que han surgido problemas de transferencia de Arduino al ATtiny. Comprobad los jumpers y, si es necesario, sustituidlos;

• comprobad que el puerto serie esté configurado correctamente.

Compatibilidad entre Arduino y los ATtinyLos microcontroladores AVR de la familia ATtiny son menos potentes que Arduino y, al programarlos con el IDE de este último, el número de funciones disponibles es limi-tado. Es posible utilizar casi todos los comandos que existen para Arduino:

• pinMode() – configura un pin como entrada o como salida;• digitalWrite() – configura el nivel de un pin digital;• digitalRead() – lee el estado de un pin;• analogRead() – lee el valor analógico de un pin;

198


• analogWrite() – configura una señal PWM;• shiftOut() – transmite un byte al pin indicado, un bit cada vez;• pulseIn() – detecta la llegada de un impulso a una entrada;• millis() – lee el número de milisegundos desde que el chip se enciende;• micros() – lee el número de microsegundos desde que el chip se enciende;• delay() – detiene la ejecución de un sketch durante el número de milisegundos

indicado;• delayMicroseconds() – detiene la ejecución de un sketch durante el número de

microsegundos indicado.

A partir de la versión 10.2 de Arduino (IDE), las funciones para la gestión serial tam-bién deberían ser compatibles con los ATtiny. Hay muchas otras funciones que son soportadas, como las de los servomotores. Buscando por Internet se encuentran mu-chas librerías dedicadas a los ATtiny, entre las cuales, la que se utiliza para los servo-motores (Servo8Bit).Si el ATtiny85 no es suficiente, se pueden utilizar otros chips. Una elección óptima es la del ATtiny2313 y la del ATtiny4312, que cuentan con un mayor números de pines, así como de una interfaz de serie. Podéis utilizar también un ATmega328, el mismo chip de Arduino.Utilizando el ATmega o el ATtiny2313, quizás necesitéis conectar un cristal de cuarzo para generar un reloj de frecuencias más elevadas. Debemos comprobar en las hojas de especificaciones técnicas a qué pines debe conectarse el cuarzo. Con un cuarzo de 16 MHz se utilizan también dos condensadores de 20 picofaradios. Conectad el reset a la línea de 5 V para habilitar el chip.

Figura 7.8 - Un chip ATmega328 en una breadboard, con un cuarzo de 16 MHz: un Arduino DIY.

199


Los fusesEl ATtiny que habéis utilizado en los ejemplos anteriores trabajará a la frecuencia de 1 MHz, utilizando la configuración de fábrica. Programando los chips con ArduinoISP, no podemos modificar los fuses según nos convenga. Para configurar el reloj interno a 8 MHz es preciso seleccionar, en Tools > Device, la opción ATtyny85 (internal 8MHz clock) y hacer clic sobre la opción Burn Bootoader en el menú Tools. El ATtiny no gestiona el bootloader y la operación configura solamente los fuses del chip. Para modificar todos los fuses según vuestras preferencias se utiliza un auténtico ISP Pro-grammer, que se combina con una herramienta para la configuración de las opciones del chip.

201

En muchas ocasiones, vuestros proyectos necesitarán senso-res para detectar fenómenos físicos, químicos o me-cánicos. Cuando creéis un nuevo circuito, analizad las inte-racciones que se producen con los usuarios e intentad utilizar

soluciones nuevas e imaginativas. Arduino puede gestio-

nar fácilmente cualquier tipo de sensor analógico o digital.

Condensadores variables y potenciómetrosEl sensor más sencillo de tipo analógico que podéis utilizar es un potenciómetro o un trimmer, es decir, un condensador variable. Se pueden utilizar estos dispositivos para controlar parámetros, externamente al circuito. Habitualmente, los potenciómetros se utilizan para modificar parámetros de uso común y los condensadores variables, mon-tados directamente sobre los circuitos impresos, para regulaciones que cambian poco con el tiempo. Los condensadores variables se pueden utilizar para simular sensores analógicos y estudiar el comportamiento de Arduino.Tanto los condensadores variables como los potenciómetros tienen una resistencia que empieza por los 0 ohms y alcanza un valor máximo. La variación de la resistencia puede ser lineal o logarítimica.En la figura siguiente podéis ver cómo conectar un potenciómetro a Arduino. Intentad utilizar un potenciómetro con un valor global de al menos una decena de kiloohms; después conectad el terminal central a una entrada analógica (por ejemplo, A0) y los otros dos a tierra y a la alimentación positiva. El pinout central pasará de 0 a 5 V pro-

Sensores

8

202


duciendo lecturas, comprendidas entre 0 y 1023. La precisión de la medida será igual al paso más pequeño que sea capaz de interpretar la entrada analógica de Arduino:

5 V / 1024 = 0,00488 V = 4,88 mV

Figura 8.1 - Esquema de conexión de un potenciómetro a Arduino.

Si el trimmer tiene un valor demasiado bajo, añadid resistores para aumentar la re-sistencia global y limitar la corriente que atravesará todo el conjunto. En estos casos, perderéis un poco de resolución, porque el intervalo útil para la lectura de la tensiones se habrá reducido: rotando el potenciómetro no empezaréis a 0 V y no llegaréis a 5 V.

La lectura de valores se efectúa con el comando analogRead(). Este sería un sketch para leer un valor analógico y mostrarlo en el Serial Monitor:


Figura 8.2 - Conexión de un potenciómetro con resistencias de “guardia”.

203

Sensores Capítulo 8

void loop() int n = analogRead(A0); Serial.println(n); delay(200);

No es necesario declarar los ingresos analógicos con pinMode en el setup().

CodificadorUn codificador rotatorio es un objeto muy similar a un potenciómetro: tiene un cuerpo con algunos pinouts y un eje que puede girar. Mientras que un potenciómetro puede llevar a cabo una rotación limitada, un codificador rota libremente sin detenerse, produciendo dis-paros porque en su interior posee pequeños contactos eléctricos que están continuamente activados mientras lo hace rotar. Un codificador de este tipo no os dirá en qué punto se si-túa el eje, sino solo en qué dirección se está moviendo: un poco como el control de volumen de las radios de los coches modernos. Algunos codificadores tienen también la posibilidad de pulsar el eje para cerrar un botón central. Los codificadores tienen distintas precisiones correspondientes al número de disparos necesarios para realizar un giro completo. Ade-más de para realizar controles, se pueden utilizar para medir la rotación de un eje motor.

Figura 8.3 - Un codificador, sus pinouts y las señales generadas.

Un codificador tiene tres pinouts, de los cuales uno es el común. Conectando el co-mún al GND, los otros pines se pueden conectar a dos entradas digitales de Arduino. Los codificadores ópticos producen muchos «falsos contactos» y habitualmente, para reducir las perturbaciones, se añaden condensadores de un centenar de nanofara-dios. En este ejemplo, las entradas conectadas al dispositivo serán configuradas como INPUT_PULLUP para simplificar el cableado.

204


Este es un sketch que puede ser utilizado para modificar el valor de una variable ro-tando el codificador:

int valor = 0;int lecturaAnterior = HIGH;

void setup() pinMode (3,INPUT_PULLUP); pinMode (4,INPUT_PULLUP); Serial.begin (9600);

void loop() int n = digitalRead(3); if ((lecturaAnterior == HIGH) && (n == LOW)) if (digitalRead(4) == HIGH) valor--; else valor++; Serial.print (valor); Serial.print ("/"); lecturaAnterior = n;

El valor modificado por la acción del codificador queda memorizado en la variable va-lor; para determinar la dirección del movimiento, es necesario guardar también toda la lectura del paso anterior con la variable lecturaAnterior. En el loop() es preciso saber en qué situación se encuentra el codificador, porque rotando el eje podría producir dos tipos de desfases distintos. Para empezar, se debe comprobar si existe alguna variación entre el estado actual del pin 3 (tomado como referencia) y el estado ante-rior (contenido en lecturaAnterior). Si hay alguna variación, se examina el pin 4 para determinar si producirá un aumento o una disminución de la variable valor.Se puede volver a escribir el sketch utilizando las interrupciones para agilizarlo; si no, siempre se vería obligado a controlar el estado del codificador. Consultad los ejem-plos proporcionados en el sitio de Arduino Playground (http://playground.arduino.cc/Main/RotaryEncoders).

LuzPodéis detectar la cantidad de luz con Arduino utilizando una fotorresistencia, es decir, un resistor que cambia el propio valor proporcionalmente a la cantidad de luz que lo gol-pea. Una fotorresistencia tiene el aspecto de un pequeño panel solar con dos terminales y sin polaridad: la podéis insertar indiferentemente en un sentido o en otro. Este dispo-sitivo presenta un valor «en reposo» que normalmente es de algunos kiloohms (aunque depende del modelo, por lo que consultad la hoja de especificaciones técnicas).

205


Para utilizarlo con Arduino, debéis crear un divisor, conectando la fotorresistencia en serie con una resistencia del valor de algunos kiloohms. El pin analógico de Arduino se conecta al punto central del divisor.

Figura 8.4 - Una fotorresistencia, su símbolo y el esquema de conexión con Arduino.

Este sería un sketch para leer el valor detectado por el componente y mostrarlo en el Serial Monitor.


void loop() int temp = analogRead(A0); Serial.println(temp); delay(200);

Intentad modificarlo para conseguir que, iluminando la fotorresistencia, el LED en el pin 13 se encienda.Hay otros sistemas para detectar luz, como fotodiodos o fototransistores, de los cua-les existen numerosos modelos. Los fototransistores pueden tener dos o tres termina-les. Los modelos con dos terminales son más sencillos de utilizar porque no requieren una polarización y se pueden utilizar simplemente como si fueran una fotorresisten-cia, conectándolos en serie a una resistencia adecuada.Un fotodiodo golpeado por la luz modifica la corriente que lo atraviesa; es posible conectarlo directamente a Arduino para crear una tensión legible por parte del mi-crocontrolador. En general, la tensión producida es muy baja y se necesita crear un circuito de interfaz para elevar el valor. Se puede utilizar un amplificador operacional que amplifique la señal (véase la Figura 8.5). Muchos de los componentes electrónicos que pueden detectar fuentes luminosas son capaces de detectar también radiaciones fuera del espectro visible. Comprobad siem-

206


pre las hojas de especificaciones técnicas para controlar si el sensor que estáis utilizan-do es adecuado para detectar el fenómeno deseado. Para medir radiaciones infrarrojas o ultravioletas, existen componentes especiales que trabajan a dichas frecuencias.

A menudo se utiliza un LED infrarrojo junto con un fototransistor para crear un acopla-dor óptico, un dispositivo que puede separar eléctricamente dos circuitos. Utilizando este expediente, podéis eliminar las interferencias eléctricas entre dos circuitos. Los optoacopladores se pueden realizar a medida, o bien comprarlos preconfeccionados, como el 4N25, un circuito integrado que contiene un LED y un fototransistor prote-gidos por un package DIL de seis pinouts. Algunos componentes están abiertos y se pueden utilizar como interruptores, de manera que el flujo luminoso pueda ser inte-rrumpido y, por tanto, generar una señal digital interpretable por Arduino. Para aislar una entrada y proteger Arduino ante posibles interferencias eléctricas, co-nectad un optoaislador como se ilustra en la Figura 8.6. El LED del optoacoplador tiene un botón conectado y el circuito en el cual se encuentra insertado está alimentado por una fuente de alimentación independiente. Pulsando el botón, el LED interno del chip se encenderá y activará el fototransistor, que debe estar conectado a los 5 V mediante una resistencia de 10 kiloohms, la cual funciona también como pull up. El conector del fototransistor se encuentra conectado a una de las entradas de Arduino. Al pulsar el botón, la entrada pasará al estado LOW.

Figura 8.6 - Conexión de un optoaislador 4N25 a Arduino para aislar una entrada digital.

Figura 8.5 - Ejemplo de conexión de un fototransistor al pin A0 de Arduino.

207


TemperaturaEs posible medir la temperatura de un modo rápido y económico mediante un termis-tor, es decir, una resistencia muy sensible al calor. Todas las resistencias son sensibles a la temperatura ambiente y, normalmente, esta característica es bastante indeseada, tanto que las resistencias modernas están fabricadas con dispositivos especiales que limitan estos efectos. La incidencia de la temperatura hace variar el valor de la resis-tencia de forma bastante lineal. Se puede utilizar esta propiedad, acentuándola para vincular directamente el valor de la resistencia a la temperatura ambiente. El termistor no tiene polaridad y podéis insertarlo en un sentido o en otro. El termistor tiene un valor de resistencia en reposo que varía con la temperatura y puede ser de algunos kiloohms. Para conectar el termistor a Arduino, debéis crear un divisor de tensión conectando en serie el termistor y una resistencia del valor de algunos kiloohms.

Figura 8.7 - Termistor, su símbolo y el modo de conexión a Arduino.

La lectura de la tensión se toma en el punto central del divisor, que va conectado a una de las entradas analógicas de Arduino. Es preciso realizar una calibración inicial, puesto que este componente no proporciona una lectura absoluta. La medida tomada con este sistema no será muy precisa.Con un sketch sencillo podemos leer la temperatura y, si esta alcanza un valor pre-determinado, encender un LED. También es preciso realizar la calibración para este sketch. Podéis realizarla utilizando el Serial Monitor, en el cual podéis leer el número devuelto desde la entrada de serie. Utilizad el número detectado para corregir el umbral preajustado en la instrucción if:

• conectad el termistor a Arduino;• cargad el sketch;• abrid el Serial Monitor. Deberían aparecer series de números que varían de for-

ma bastante estable en torno a un valor, por ejemplo, 300;

208


• tocad el termistor para calentarlo y, en cuanto veáis que los números en el Se-rial Monitor crecen, anotad el valor alcanzado (por ejemplo, 310);

• modificad la instrucción if insertando como umbral un número ligeramente menor al que acabáis de leer (por ejemplo, 308).


void loop() int temp = analogRead(A0); Serial.println(temp); if (temp >= 308) digitalWrite(13, HIGH); else digitalWrite(13, LOW); delay(200);

Con un sensor más complejo, como el LM35, es posible recoger una medida absoluta y muy precisa de la temperatura (en décimas de grado), sin necesidad de realizar ninguna calibración. El sensor LM35 parece un pequeño transistor: dos de los termi-nales se conectan a la alimentación (5V y GND) y el tercero proporciona una tensión proporcional a la temperatura. El intervalo de temperaturas que se pueden medir va de 0 °C a 50 °C24 con una resolución variable de 1/4 a 3/4 de grado en los casos más extremos. Para determinar la temperatura, simplemente leéis el voltaje y lo transfor-máis en el valor de temperatura, teniendo en cuenta que 10 milivoltios corresponden a un grado.

Generad un sketch donde se lea el valor analógico proporcionado por el sensor: ten-dréis que convertir el número entero devuelto por analogRead() en un voltaje corres-

24 Es posible ampliar el intervalo de medida de -50 a +150 °C añadiendo componentes externos al sensor. Para más detalles, consultar la hoja de especificaciones técnicas.

Figura 8.8 - Uso del sensor LM35 con Arduino.

209


pondiente a la temperatura. Si habéis conectado el sensor a la entrada A0, la tempe-ratura la dará:

int voltaje_en_milivoltios = analogRead(A0) * (5000/1024);int temperatura = voltaje_en_milivoltios / 10;

Cada unidad proporcionada por analogRead() es igual a unos 5 milivoltios. Por esta razón, en primer lugar debéis calcular el voltaje presente en la entrada A0; a con-tinuación, sabiendo que 10 milivoltios corresponden a un grado, será muy sencillo obtener la temperatura dividiendo el voltaje entre 10.Otro sensor que se utiliza mucho para la lectura de temperaturas, aunque no es muy fácil de usar con Arduino, es el termopar. Un termopar proporciona una tensión pro-porcional a la temperatura y puede medir intervalos muy amplios, si bien de forma no muy precisa. Su uso requiere dispositivos especiales, porque proporciona valores de tensión muy bajos. Podéis conseguir una shield para termopares, o bien añadir un pequeño amplificador a la entrada de vuestro circuito.

HumedadLa manera más sencilla de medir la humedad es utilizando dos extremos de cable e introduciéndolos en el suelo. Si el suelo está húmedo, la resistencia disminuye y pro-porciona una indicación proporcional al porcentaje de agua existente. Podéis construir un sensor de este tipo utilizando un transistor para aumentar el nivel de la señal me-dida, o podéis comprar un detector ya preparado con un transistor y varias sondas. La señal que proporciona es analógica y, por lo general, no es demasiado precisa, pero puede ir muy bien para diseñar un sencillo sistema de riego para saber simplemente si el suelo necesita agua o no.Para medir la humedad del aire existen dispositivos específicos. Uno de los más uti-lizados se denomina DHT11 y es un sensor para el control ambiental que detecta la temperatura y la humedad del aire. Los datos medidos se muestran en una interfaz de serie. A pesar de su bajo precio, el DHT11 proporciona datos bastante precisos y es duradero y estable. Los sensores internos de temperatura y humedad se calibran y compensan gracias al circuito integrado situado en su interior. El DHT puede medir temperaturas de 0 a 50 °C y la humedad relativa del 20 al 90 %, con una sensibilidad de una décima de grado para la temperatura y de un punto porcentual para la hume-dad. Resulta ideal para construir pequeñas estaciones meteorológicas.

210


El sensor transmite los datos en formato digital y, para la lectura, basta con utilizar un único pin para la recepción de informaciones. Antes de leer los datos, se aconseja esperar al menos un segundo desde el momento del encendido, para que el elemento tenga tiempo de estabilizarse.La librería para el sensor se puede descargar desde la siguiente dirección: http://www.dfrobot.com.cn/image/data/DFR0067/dht11.zip.Este es el sketch proporcionado junto con la librería:

#include <dht.h>dht DHT;#define DHT11_PIN 2

void setup() Serial.begin(9600); Serial.println("DHT TEST PROGRAM "); Serial.print("LIBRARY VERSION: "); Serial.println(DHT_LIB_VERSION); Serial.println(); Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");

void loop() Serial.print("DHT11, \t"); chk = DHT.read11(DHT11_PIN); switch (chk) case DHTLIB_OK: Serial.print("OK,\t"); break; case DHTLIB_ERROR_CHECKSUM: Serial.print("Checksum error,\t"); break; case DHTLIB_ERROR_TIMEOUT: Serial.print("Time out error,\t"); break; default: Serial.print("Unknown error,\t"); break; Serial.print(DHT.humidity,1); Serial.print(",\t"); Serial.println(DHT.temperature,1); delay(1000);

Figura 8.9 - Conexión del sensor DHT11 con Arduino.

211


Importáis la librería a Arduino con el procedimiento habitual y creáis un nuevo sketch. Al inicio del código, incluís el módulo de librería dht.h. Esta librería os permite crear un objeto dht que, más tarde, utilizaréis en el sketch. En la tercera línea del código, con una define#, se debe indicar a la librería en qué pin se encuentra conectado el sensor.La lectura de los datos se produce en el loop(): con DHT.read(numero_pin) se solicita una lectura. La operación devuelve un código de estado que indica si se ha completado correctamente o si ha surgido algún error. Para obtener los valores detectados, se utilizan DHT.humidity y DHT.temperature.

GasesPara medir los gases presentes en el aire, existen pequeñas cápsulas adecuadas para distintos tipos y que proporcionan lecturas analógicas proporcionales a la concentra-ción de gases en el aire. En el mercado encontraréis una serie de sensores, entre los cuales algunos muy conocidos denominados MQ. Cada sensor puede medir distintos tipos de gases detectando las diferentes concentraciones. Existen sensores específi-cos para un único tipo de gas, aunque seguramente sean muy caros. Los sensores de tipo MQ utilizan un elemento calefactor alimentado a 5 V, acoplado a un detector. Al conectar uno de estos sensores a Arduino, es preciso prestar mucha atención a los ca-bles: en caso de error, se puede dañar irreparablemente el detector de gas (y algunos valen decenas de euros). Si tenéis alguna duda, podéis comprar una placa breakout con el sensor ya conectado y preparado para su uso. El elemento calefactor a veces está alimentado a 5 V, pero en algunos modelos se utilizan tensiones de distinto valor (también en estos casos es aconsejable recurrir a una placa breakout). La presencia de un elemento calefactor puede ser un problema para instalaciones con batería: el sensor debe ser calentado a unos cincuenta grados durante unos minutos antes de poder ser utilizado; el consumo de corriente puede ser importante. Algunos sensores requieren una especie de rodaje de entre 12 y 24 horas.La salida del sensor no puede conectarse directamente a Arduino, sino que se utiliza una resistencia de carga para generar la tensión que permite leer al microcontrolador. La re-sistencia tiene un valor de varios kiloohms (como máximo, unos 50) e influye en la sen-sibilidad de las medidas. Para evitar errores, usad una resistencia entre 10 y 20 kiloohms.

Figura 8.10 - Un sensor de tipo MQ.

212


Existen muchos modelos disponibles. Estos son solo algunos:• MQ2 – metano, butano, GPL y humo;• MQ3 – alcohol, etanol y humo;• MQ4 – metano;• MQ7 – monóxido de carbono (CO);• MQ8 – hidrógeno;• MQ131 – ozono.

Y aquí tenéis algunos vínculos:• http://bit.ly/arduino_mq – lista bastante completa de sensores;• http://bit.ly/sensori_mq – tabla con los gases y la sensibilidad de los sensores.

Sensor de efecto HallEl sensor de efecto Hall sirve para detectar la presencia de un campo magnético o electromagnético. Es un sensor de tipo analógico que produce una tensión propor-cional a la señal captada. Las lecturas difieren según la orientación del sensor. Como los imanes tienen polaridad, la tensión variará según la orientación hacia la cual esté situado el dispositivo respecto al campo a medir.Algunos sensores son muy precisos, mientras que otros detectan solo campos de gran intensidad. Normalmente son de tipo lineal, aunque existen algunos modelos que pre-sentan una salida digital: en cuanto detectan una señal de cierta intensidad, la salida se ajusta al nivel alto (véase la Figura 8.12).En general, en ausencia de campo magnético, la señal de salida del sensor se pone a la mitad de la tensión de alimentación para variar hacia el valor máximo o 0 , según la orientación del campo.

Figura 8.11 - Conexión de un sensor a Arduino.

213


Figura 8.12 - Uso de un sensor de efecto Hall.

El sensor AH49E mide un campo magnético hasta cerca de un millar de gauss y se puede considerar bastante sensible. El dispositivo tiene el aspecto de un transistor bipolar y se alimenta con una tensión de entre 3 y 5 V. Las medidas obtenidas no son, generalmente, muy precisas y pueden variar de manera importante: también porque vivimos en un entorno muy ruidoso desde el punto de vista electromagnético. El sen-sor puede ser utilizado como un interruptor “oculto” activado por un imán para detec-tar o medir movimientos y velocidades de rotación de un motor (como un codifica-dor), medir una distancia (aproximada) o comprobar si por un cable circula corriente.

Sensor de inclinaciónPara detectar una determinada inclinación podéis utilizar un tilt sensor o sensor de incli-nación, es decir, pequeñas ampollas que contienen contactos sumergidos en una gota de mercurio u otros elementos conductores líquidos. Estos sensores se fijan en el cuerpo cuya inclinación hay que controlar y, cuando se alcanza el ángulo correcto, la gota de mercurio cierra el contacto. Es un sistema muy sencillo y económico para detectar si un elemento, por ejemplo, parte de una maquinaria, está en la posición correcta. Estos sensores son equi-parables a los botones, se leen como entradas digitales y podrían presentar fenómenos de rebote, que se pueden eliminar introduciendo retardos o mediante técnicas de debouncing.

PIREl PIR (Passive InfraRed sensor) detecta los rayos infrarrojos emitidos por objetos ambientales y se puede utilizar para detectar una presencia humana dentro de su radio de acción. El sensor se define como «pasivo» porque no incluye un emisor de infrarrojos, sino que detecta la radiación emitida por cuerpos que caen en su campo de acción. Todos los objetos emiten energía en forma de rayos infrarrojos: cuanto más caliente está un objeto, mayor será la cantidad de radiación emitida.

214


Los PIR sirven para detectar movimientos: memorizan la cantidad de radiación pre-sente en el entorno y, en cuanto detectan una variación, hacen que se cierre un con-tacto. Los modelos más precisos incluyen ajustes para modificar la sensibilidad y el campo de acción del sensor. A menudo, el sensor está protegido en una cobertura. Del PIR salen tres cables: dos sirven para la alimentación y el tercero, para conectar a una entrada digital, para detectar la señal.En lugares muy iluminados o bastante complejos y ruidosos, la calibración del sensor puede resultar muy difícil.

Podéis conectar a vuestro Arduino PIR complejos y costosos utilizados, por ejemplo, en alarmas antirrobo, o bien placas muy sencillas que valen poco dinero.

Sensores capacitivosEl cuerpo humano posee una carga eléctrica que puede ser medida con una simple hoja de aluminio conectada a Arduino. Con un sensor capacitivo se puede detectar el toque o la cercanía de una persona hasta aproximadamente 30 o 40 centímetros, según los componentes utilizados. Para su uso con Arduino, es necesario realizar cál-culos sobre la cantidad de carga medida que podrían ser bastante complicados. Afor-tunadamente, es posible descargar una librería, escrita por Paul Badger, que puede desarrollar todos estos cálculos por nosotros (http://bit.ly/caplib_arduino).

Figura 8.13 - Un PIR conectado al pin 2 de Arduino.

Figura 8.14 - Cómo realizar un sensor capacitivo con una resistencia y un pedazo de cable eléctrico.

215


La creación del sensor es muy sencilla: solo necesitáis un pequeño rectángulo de alu-minio y una resistencia. El valor de la resistencia determinará la sensibilidad del dis-positivo: cuanto mayor sea el valor, más elevada será la sensibilidad. Podéis utilizar una resistencia de 1 megaohm para tener la mínima sensibilidad: será suficiente con tocar el rectángulo de aluminio. Si la resistencia es muy elevada (30 o 40 megaohms), el sensor detectará vuestra presencia desde una distancia de unos treinta centíme-tros. Conectad la resistencia entre los pines 2 y 4 y el sensor, al pin 2. Calibrando adecuadamente la resistencia, podéis esconder la placa de aluminio detrás del papel, del plástico o de la madera, haciendo que el sensor sea completamente invisible. La librería activa uno de los dos pines y después mide el tiempo necesario para recibir la señal en el segundo pin. La medida depende del valor de la capacidad creada entre la placa y una persona. El mismo sistema puede ser utilizado para detectar una dis-tancia o incluso la presión (aislando la placa con una sutil hoja de papel o de plástico) realizada sobre la placa.Si el circuito es inestable, es aconsejable insertar un condensador de 100 picofaradios entre sensor y tierra. También sería preferible conectar a tierra Arduino, mediante un terminal GND a un radiador o a una toma de tierra.En el mercado existen pequeñas placas para gestionar nosotros solos un cierto núme-ro de sensores capacitivos. Estas placas liberan a Arduino de la gestión del cálculo de las cargas detectadas y proporcionan sencillas salidas digitales para conectar al mi-crocontrolador. Si tenéis la intención de construir un panel de control muy complejo, con varios sensores capacitivos, valorad una de estas placas porque podría facilitar la creación de vuestro proyecto.Este es un sketch para usar el sensor capacitivo conectado a los pines 2 y 4 de Arduino:

#include <CapacitiveSensor.h> CapSense cs = CapSense(4,2); void setup() cs.set_CS_AutocaL_Millis(0xFFFFFFFF); Serial.begin(9600); pinMode(13, OUTPUT); void loop() int sens = cs.capSense(30); if (sens > 1000) digitalWrite(9, HIGH); else digitalWrite(9, LOW); delay(100);

216


Medidores de distancias por infrarrojosTambién los rayos infrarrojos se pueden utilizar para medir una distancia. Existen senso-res digitales que pueden detectar solo la presencia de un obstáculo sin que se produzca un contacto real y sensores más sofisticados que pueden dar una información relativa a la distancia a la que se encuentra un objeto. Para crear un sensor por IR podéis acoplar un LED IR y un sensor adecuado (por ejemplo, un fototransistor), pero de este modo no obtendréis una gran precisión. Si queréis algo más fiable, podéis comprar un sensor integrado como los que produce la casa Sharp, que son de los más utilizados para estos fines. Los distintos modelos tienen características diferentes y son capaces de detectar objetos a distancias más o menos elevadas y con varias resoluciones. Los sensores por infrarrojos tienen los mismos problemas porque en el entorno existen numerosas in-terferencias que pueden invalidar las informaciones producidas: podrían haber grandes diferencias si se utilizan de día o de noche, o en un entorno más o menos caliente.El sensor emite un impulso de luz con un ángulo preciso y mide el ángulo de regreso. Con esta información es posible determinar si el objeto se encuentra en el campo de detección del sensor. La radiación puede reflejarse en distintas superficies de varias formas y esto proporciona resultados bastante variables y no siempre fiables.Para hacer un experimento, podéis conseguir un sensor Sharp GP2Y0A21YK0F, que puede detectar objetos en un rango de 10 a 80 centímetros. La señal que produce es de tipo analógico y puede ser leído desde uno de los pines de Arduino.

Podéis construir el sensor utilizando uno o más LED IR y un detector IR (por ejemplo, un Panasonic PNA4602m), que es algo más que un simple fototransistor, puesto que ha sido diseñado para ser utilizado con telecomandos por infrarrojos y sistemas de medición. Para hacer que la señal sea más resistente ante las interferencias, en lugar de encender simplemente el LED por infrarrojos, debéis generar un impulso a 38 kHz. Así, será posible eliminar el ruido de fondo y las interferencias. El PNA4602m incluye circuitos para filtrar impulsos a 38 kHz.

Figura 8.15 - Medidor de distancias por infrarrojos.

217


El LED está conectado a una resistencia con un valor que puede variar entre 1000 y 220 ohms. Con el valor más bajo de resistencia se conseguirá un sensor con un rango más amplio.El fototransistor también está conectado a una resistencia de 220 ohms. El valor de salida es extraído y leído por una de las entradas analógicas de Arduino.

A continuación, os muestro un posible sketch para utilizar el sensor PNA4602m. El LED del dispositivo está conectado al pin 4 y el sensor, al pin 5 de Arduino.

//declaración de la función para la lectura del sensorint letturaIR(int readPin, int triggerPin);

void setup() pinMode(4, OUTPUT); pinMode(5, INPUT); Serial.begin(9600);

void loop() Serial.println(letturaIR(5,4)); delay(100);

int letturaIR (int readPin, int triggerPin) //para generar 38,5kHz se necesita un periodo de 26 microsegundos int halfPeriod = 13; // 38 ciclos son igual a casi un impulso de 1 milisegundo de duración int cycles = 38; int i; for (i=0; i <=cycles; i++) digitalWrite(triggerPin, HIGH); delayMicroseconds(halfPeriod); digitalWrite(triggerPin, LOW); delayMicroseconds(halfPeriod - 1); //12 us para compensar los retrasos de las digitalWrite return digitalRead(readPin);

Figura 8.16 - Pinout del sensor PNA4602m: 1 es la salida, 2 es el GND y 3 es VCC.

218


El sketch produce un impulso de 1 milisegundo de duración y una frecuencia de 38 kHz. El hecho de tener que generar un impulso de este tipo se debe a que el sensor está ajustado a esta frecuencia e ignorará cualquier otra señal: así es posible eliminar las interferencias.Tras haber enviado el impulso, el sketch pasa inmediatamente a leer el pin al cual está conectado el sensor, para ver si se ha detectado alguna señal. En dicho caso, se trata solo de la detección de la presencia de un obstáculo y no de la medida de la distancia.

Los sensores por IR ajustados en la frecuencia de 38 kHz pueden ser utilizados para interpretar las informaciones transmitidas por telecomandos. Existen librerías especí-ficas para desarrollar estas operaciones, que os permiten transformar Arduino en un control remoto universal. Los sensores específicos para recibir señales transmitidas por mandos a distancia tienen un pequeño chip en su interior que sirve para filtrar la señal e aceptar solo las señales moduladas a 38 kHz. Los sensores tienen normalmen-te tres pinouts: dos para la alimentación y uno para la señal de salida. El pinout varía mucho de un modelo a otro. La señal producida es de tipo digital y normalmente se encuentra en el estado alto; si se detecta algo, pasa al nivel bajo.Para leer las señales que proceden de un control remoto, podéis utilizar un sensor PNA4602 conectado directamente a uno de los pines de Arduino. Las señales trans-mitidas están formadas por impulsos de 38 kHz. La señal necesaria para encender un televisor está formada por docenas de pequeños paquetes de 38 kHz de distintas duraciones, en rápidas secuencias. Existe una librería que simplifica las operaciones necesarias para descodificar (y producir) estas secuencias de impulsos. La librería se puede descargar desde la dirección http://bit.ly/arduino_ir_remote.En algunos casos, la nueva librería podría entrar en conflicto con la librería RobotI-Rremote de Arduino. Podéis eliminar esta última desde la carpeta de instalación de Arduino; allí, borráis o cambiáis de ubicación la librería que encontraréis en la carpeta.

Figura 8.17 - Esquema eléctrico de conexión del LED y del sensor por infrarrojos.

219


El sketch para leer los códigos es bastante sencillo:

#include <IRremote.h>IRrecv ricevitore(3);decode_results mensaje;

void setup() Serial.begin(9600); //activo el sensor ricevitore.enableIRIn();

void loop() if (receptor.decode(&mensaje)) Serial.println(mensaje.value, DEC); //habilita el receptor para recibir una nueva señal receptor.resume();

Apuntad el sensor con el mando a distancia y pulsad un botón. En el Serial Monitor veréis que aparece una secuencia de números tipo:

13425566662266773466226677346622667734

El código importante es el primero que se muestra y podéis utilizarlo en el sketch para llevar a cabo una acción vinculada a la pulsación del botón del mando. La librería os permite también transmitir códigos y utilizar Arduino como si fuera un control remoto.Encontraréis un interesante tutorial en el sitio Instructables (http://bit.ly/ricevitore_ir).

UltrasonidosLas emisiones de ultrasonidos no son audibles por el oído humano y pueden ser uti-lizadas para medir la distancia de un objeto o de un obstáculo. Se utilizan mucho en robots, porque son económicas y funcionan bastante bien. El principio es similar al del radar: se emite un impulso e, inmediatamente, escucha, midiendo el tiempo transcu-rrido desde su emisión y, a veces, la intensidad recibida.Podéis utilizar un sensor SRF05 para detectar objetos hasta una distancia de 4 metros. En el sensor se montan dos cápsulas, una para emitir los ultrasonidos y otra, para reci-birlos. Las operaciones de descodificación y elaboración son desarrolladas por algunos circuitos integrados incluidos en la placa. La placa puede ser controlada con dos pines denominados “trigger” y “echo”, o bien con un único pin que lleva a cabo ambas funcio-nes. El tipo de funcionamiento se selecciona utilizando el pin “mode”: si se deja desco-

220


nectado, el sensor utilizará pines separados para echo y trigger; si no, es preciso conectar el pin al GND. Resulta más sencillo utilizar dos pines separados, donde trigger se utiliza para enviar el impulso y echo, para recibir la respuesta. Para enviar un impulso, se debe activar el trigger durante al menos 10 microsegundos; después, si se recibe algo, la línea echo pasa del estado alto al estado bajo. La duración de la señal presente en el pin echo es proporcional a su distancia. Para calcular la distancia (en centímetros), se debe medir la duración del impulso en microsegundos y después, dividirla entre 58.

Figura 8.18 - Pinout del sensor SRF05 y conexión a Arduino.

Conectad el sensor como en el circuito de la figura: el SFR05 se conecta con un único pin. Para utilizar este sensor no se necesita ninguna librería. El sketch sería el siguiente:

void setup() Serial.begin(9600); void loop() pinMode(8, OUTPUT);

//transmisión echo digitalWrite(8, LOW); delayMicroseconds(2); digitalWrite(8, HIGH); delayMicroseconds(10); digitalWrite(8, LOW);

//lectura pinMode(8, INPUT); int duración = pulseIn(8, HIGH); int dist = duración/58; Serial.print("distancia: "); Serial.println(dist);

delay(100);

221


El sensor se controla con un único pin, utilizado para iniciar el eco y para recibirlo. An-tes que nada, será necesario enviar el echo poniendo el pin de control en el estado LOW durante 2 microsegundos; después, en el estado HIGH durante 10 microsegundos, y por último, de nuevo, en LOW. Una vez enviado el eco, se deberá utilizar el mismo pin como entrada. La duración del impulso recibido se mide con pulseIn(). El valor obtenido di-vidido entre 58 proporciona la distancia del objeto detectado por el sensor.

Acelerómetro y giroscopioUna amplia gama de circuitos integrados de bajo coste ha puesto a disposición de los diseñadores numerosos métodos para detectar la posición de un objeto. Actualmente, un simple chip de menos de un euro es capaz de medir las aceleraciones a lo largo de tres ejes perpendiculares. Los modelos más sencillos y menos precisos ejecutan mediciones analógicas y proporcionan tres señales que pueden ser leídas desde las entradas analógicas de Arduino. Otros circuitos integrados tienen una salida de serie y la lectura es menos inmediata.Muchos de estos chips son producidos exclusivamente en formato SMD (como el modelo MMA7371, de montaje superficial) y no pueden ser utilizados sobre una brea-dboard. Podéis comprar placas breakout estándar y soldar sobre ellas los chips (nece-sitaréis herramientas específicas), o bien podéis comprar placas preparadas para el cableado. La tecnología de producción se denomina MEMS (Micro Electro-Mecha-nical Systems), para indicar que estos circuitos integrados contienen en su interior estructuras electromecánicas de dimensiones microscópicas (aquellas que también conocemos como nanotecnología).Los acelerómetros miden la entidad de la fuerza a lo largo de distintas direcciones. Cuando el sensor se detiene en un plano, se detectará solo la aceleración vertical producida por la fuerza de gravedad. Si movéis o rotáis el sensor, veréis cambiar las señales detectadas en los tres ejes.Un acelerómetro puede ser utilizado para determinar la posición de un objeto, pero es preferible utilizar un chip giroscópico, que proporciona una indicación sobre la orien-tación en lugar de sobre las fuerzas detectadas. El giroscopio os dará una lectura de la aceleración angular a lo largo de los tres ejes principales (véase la Figura 8.19). Un ejemplo de giroscopio con acelerómetro incorporado es el chip InvenSense MPU-6050, que contiene un acelerómetro MEMS y un giroscopio MEMS, ambos de tres ejes. El chip tiene una interfaz l2C para la comunicación con un microcontrolador y trabaja con una tensión de 3 a 5 V. La sensibilidad de las mediciones puede variar entre 2 y 16 G en el caso del acelerómetro y entre 250 y 2000 °/s en el caso del giroscopio.

222


Muchos chips tienen en su interior un convertidor analógico-digital, que convierte las señales analógicas y las vuelve disponibles a través de una interfaz serial o I2C.

Figura 8.19 - Acelerómetro con interfaz I2C y esquema de conexión a Arduino.

Utilizar un simple acelerómetro analógico es muy sencillo, porque proporciona direc-tamente tres señales de tensión correspondientes a las tensiones en los tres ejes X, Y y Z. Las señales se pueden leer con analogRead(). Estad atentos, porque en ocasiones estos chips se alimentan a 3,3 V.

BrújulaChips como los modelos HMC5883L y HMC6352 pueden detectar el campo mag-nético terrestre con notable precisión, proporcionando la orientación con precisión de medio grado y también la intensidad del campo medido. Estos chips contienen sensores magnetorresistivos que detectan y miden la intensidad magnética a lo largo de tres ejes perpendiculares.

Figura 8.20 - Acelerómetro analógico y esquema de conexión a Arduino.

223


Estos chips son muy difíciles de soldar porque tienen sus contactos debajo de su per-fil: es preciso soldarlos con un flujo de aire caliente o utilizando instrumentos espe-ciales. Como siempre, encontraréis en el mercado placas breakout prefabricadas que podéis conectar rápidamente a Arduino. La comunicación se lleva a cabo a través de un canal l2C. El coste de estos componentes, antes bastante elevado (sobre unos 30 euros), está disminuyendo progresivamente, tanto que hoy en día una placa breakout con brújula puede costar unos diez euros.

El módulo de la brújula se alimenta a 3,3 V y no a 5. Comprobad bien las conexiones para no dañar el pequeño chip, caro y delicado. Después, conectad el terminal SDA al pin A4 de Arduino y el SCL, al pin A5. Para la lectura y la configuración del chip, podéis descargar una librería específica que simplifica las operaciones: es un poco difícil de encontrar, pero he localizado una copia en la dirección http://bit.ly/lib_HMC5883L.Tras haber instalado la librería, encontraréis un ejemplo completo (que podréis utilizar como punto de partida) en el menú File > Ejemplos > HMC5883L > Simple.

GPSEntre los sensores más complejos y caros, encontramos los módulos GPS, con los cuales es posible localizar con gran precisión la posición de vuestro prototipo. Estos módulos son fundamentalmente radios: están dotados de una antena integrada, que a su vez se puede conectar a una antena externa, y una lógica de control en general con-tenida en un chip. Los módulos para Arduino se pueden comprar como shield o bien en formato de placa breakout. No son necesarias mucha conexiones con Arduino, puesto que los datos se transmiten a lo largo de una línea de serie.Una vez encendido el módulo, se necesita un poco de tiempo para que la antena de-tecte los satélites. En ocasiones, la espera puede ser larga, especialmente si hay pocos satélites por la zona.

Figura 8.21 - Placa breakout con brújula conecta-da vía l2C a Arduino.

224


El módulo GPS proporcionará una larga cadena de informaciones con fecha y hora, coordenadas y altura del punto medido. La precisión es siempre bastante exacta y el consumo, elevado. El formato de los datos deber ser compatible con el protocolo NMEA (National Marine Electronics Association).Cada placa tiene sus propias características específicas, por lo que, según el modelo elegido, es preferible utilizar las librerías combinadas o recomendadas. Si es posible, comprad un modelo que transmita los datos en una simple línea serial. Los datos reci-bidos estarán en un formato de este tipo (NMEA):

$GPGGA,105317.709,8960.0000,N,00000.0000,E,0,0,,137.0,M,13.0,M,,*4C

Los campos contienen informaciones sobre la posiciones, que se identifican por nú-meros seguidos de N o de E (o W). Para interpretarlos, basta con saber en qué posi-ción se encuentra cada información dentro de la cadena y, después, proceder con las oportunas conversiones. Os iría bien utilizar la librería TinyGPS pra descodificar fá-cilmente la cadena con las informaciones (http://arduiniana.org/libraries/tinygps/).Algunos de los modelos más utilizados son: EM-406A, EM-506, ETek EB-85A FV-M8, Tyco A1035-D, Copernicus II de Trimble. Los distintos productos están equipados con antenas incorporadas, o de tipo cerámico, y tienen frecuencias de actualización que pueden variar de una a diez veces por segundo. Las características influyen en el pre-cio, que puede llegar a los 70 euros o más.Para más información: http://playground.arduino.cc/Tutorials/GPS.

Hora y fechaEl tiempo puede considerarse como un fenómeno que se puede medir y puede parecer una tarea sencilla. De hecho, entre las instrucciones de Arduino, hay algunas para ob-

Figura 8.22 - Un módulo GPS de tipo serial.

225


tener el número de milisegundos transcurridos desde la última vez que fue encendido. Con alguna línea de código, es posible crear un simple reloj, bastante preciso pero que perderá todos sus ajustes cada vez que se apague. Si queréis un reloj fiable, es preciso encontrar la manera de que esté siempre alimentado.Existen chips especialistas en memorizar y mantener la fecha y la hora. Estos circuitos deben conectarse a una batería tampón, de las de botón, consumen muy poco (una batería dura varios años), son muy precisos y, aunque Arduino se apague, mantiene la hora y la fecha hasta el próximo encendido.Uno de estos chips es el DS1307, disponible también en formato DIL (que puede mon-tarse fácilmente en una breadboad). Estos chips son muy útiles para realizar data log-ger, que registran datos añadiendo la fecha y la hora de la medida. Existen varias Data Logger Shield equipadas con un reloj integrado y dotadas de tarjeta SD para guardar los datos. Podéis utilizar el chip también por separado, conectándole la batería y un cuar-zo adecuado (véase la hoja de especificaciones técnicas). La batería debe incluirse siempre, aunque se descargue, para evitar un mal funcionamiento. La comunicación se realiza con un canal l2C.

Figura 8.23 - Esquema de los pines y conexión del chip DS1307 a Arduino.

Para utilizar el chip, se necesita una librería que podéis descargar desde el sitio de Adafruit (http://bit.ly/realtime_lib_arduino) e instalar en el editor de Arduino.La primera vez que utilicéis el chip, tendréis que ajustar la hora y la fecha. La librería os ofrece un método para configurar automáticamente las informaciones necesarias tomán-dolas de vuestro PC. Este es el sketch para ajustar la hora. Copiadlo y cargadlo en Arduino.

#include <Wire.h>#include "RTClib.h" RTC_DS1307 RTC; void setup ()

226


Serial.begin(57600); Wire.begin(); RTC.begin(); if (! RTC.isrunning()) RTC.adjust(DateTime(__DATE__, __TIME__)); Serial.println("¡Fecha y hora configuradas!");

void loop()

En el sketch tenéis que insertar la librería Wire.h para gestionar las comunicaciones con el protocolo l2C y RTCLib.h, para utilizar el DS1307. Cread un objeto de tipo RTC_DS1307 llamado RTC que iniciaréis en el setup() y que representa, desde el punto de vista del “software”, el chip. La librería para la comunicación también debe ser iniciada. El objeto RTC tiene un método que sirve para comprobar si ha sido inciado y, en caso con-trario, pasa a configurar fecha y hora usando las variables especiales que contienen las informaciones necesarias, copiadas del PC en el cual ha sido compilado el sketch.Una vez apagado Arduino, el chip mantendrá las informaciones actualizadas (hasta que no se extraiga la batería tampón). Para obtener la hora y la fecha, solo tenéis que interrogarlo y leer los datos proporcionados. A continuación se muestra el sketch para la lectura de los datos actuales.

#include <Wire.h>#include "RTClib.h" RTC_DS1307 RTC; void setup () Serial.begin(57600); Wire.begin(); RTC.begin(); void loop () DateTime now = RTC.now(); Serial.print(now.year(), DEC); Serial.print('/'); Serial.print(now.month(), DEC); Serial.print('/'); Serial.print(now.day(), DEC); Serial.print(' '); Serial.print(now.hour(), DEC); Serial.print(':'); Serial.print(now.minute(), DEC); Serial.print(':'); Serial.print(now.second(), DEC); Serial.println();

227


delay(3000);

El sketch es muy similar al que se utiliza para la iniciación. Para leer la fecha y la hora, se utiliza el método now() del objeto RTC. El dato proporcionado se guarda en el for-mato especial DateTime que os ofrece métodos muy prácticos para obtener año, mes, día, hora, minutos y segundos. Tras haber cargado el sketch, abrid el Serial Monitor, ajustando la velocidad a 57.600 baudios. Cada 3 segundos veréis aparecer la fecha y la hora actuales.Como práctica, cread un reloj con Arduino conectando el módulo RTC a una pantalla de cristal líquido.La librería RTCLib.h dispone de otros métodos para manipular fechas, horas y tiempos. Podéis encontrar más información en el sitio de Adafruit, desde el cual habéis descar-gado la librería.

Figura 8.24 - La fecha y la hora actuales producidas por el chip DS1307.

Conectar un micrófono o una fuente de audioPara analizar sonidos con Arduino, conectad un micrófono a uno de los pines analógi-cos. Existen distintos tipos de micrófonos, pero todos producen una señal muy baja. Por esta razón, es preciso utilizar un amplificador: es muy sencillo fabricar uno sobre una breadboard utilizando un op-amp (véase Elettronica per maker). Obviamente, tam-bién en este caso existen placas breakout especiales donde el micrófono se encuentra soldado en el circuito impreso dotado de un amplificador. Con tres simples cables podéis recibir una señal de audio adecuada para ser interpretada y leída con vuestro

228


Arduino. Debéis tener en cuenta que Arduino no puede realizar elaboraciones muy complejas sobre las señales de audio, aunque es posible efectuar algún experimento.Si, en lugar de una señal de audio desde un micrófono, queréis elaborar una procedente de un equipo de sonido o un lector MP3, podéis conseguirlo con algunos sencillos com-ponentes pasivos.

Figura 8.25 - Esquema de conexión de una señal de audio procedente de un equipo de música o de un lector mp3.

El circuito utiliza dos resistencias de 100 kiloohms para centrar la señal de audio a 2,5 V. La entrada está separada con un condensador electrolítico de microfaradios que deja pasar solo las variaciones de la señal.Arduino no es muy adecuado para ejecutar creaciones de audio en tiempo real, por-que logra ser muestreada a una frecuencia de unos 10 kHz. Esto significa que, cuando una señal analógica llega a una de sus entradas analógicas, se transforma en un nú-mero, es decir, en una muestra digital. La placa puede recoger unas 10.000 muestras por segundo, que parecen muchas, pero que en realidad no son suficientes para re-construir fielmente una señal de audio, para lo cual se necesitarían al menos 44.000 muestras por segundo. La frecuencia de muestreo debe ser, como mínimo, el doble de la máxima frecuencia presente en la señal: el audio de buena calidad tiene una frecuencia máxima de 22 kHz, que requiere, por tanto, una frecuencia de muestreo de 44 kHz. La frecuencia de 10 kHz es suficiente para muestrear la voz humana de un modo bastante comprensible.

RFIDUn tipo de dispositivos extremadamente interesante que podéis utilizar con Ardui-no son los lectores RFID (Radio-Frequency IDentification, es decir, “identificación por radiofrecuencia”). Un lector de este tipo utiliza una antena para identificar tags (eti-quetas electrónicas o transpondedores). El lector envía un impulso de radio y el trans-

229


pondedor, activado por la energía del impulso, responde con un código identificativo propio. Las etiquetas tienen un pequeño chip que se ocupa de la retransmisión. El lector es capaz de modificar el estado del chip incluido en la etiqueta. Los chips pue-den ser insertados realmente en etiquetas porque son minúsculos. Se utilizan mucho como sistema antirrobo o en tarjetas o smart card. La evolución de esta tecnología se denomina NFC (Near Field Communication) y utiliza también una comunicación bidireccional.En el mercado existen dispositivos de muchos tipos, como el Innovation ID-12 con antena integrada, que cuesta unos diez euros, o el RC522 de MIFARE, a un precio mu-cho más asequible. Los distintos dispositivos pueden tener modalidades de funciona-miento distintas y los datos se proporcionan desde una línea de serie. El módulo ID-12 puede ser conectado a un LED o a un zumbador para dar confirmación de la lectura y se comunica con una línea de serie. El lector RC522 de MIFARE requiere una librería específica y se comunica utilizando el protocolo SPI.Veamos un ejemplo con el módulo RC522 de MIFARE. Para empezar, es necesario efectuar el cableado del lector a Arduino. Prestad mucha atención a la tensión de alimentación porque este lector trabaja a 3,3 V y no a 4. En la placa, cada pin está mar-cado con un nombre. Conectad los pines como se indica a continuación (el ejemplo está pensado para Arduino Uno):

• RST al pin 9 de Arduino;• SDA al pin 10;• MOSI al pin 11;• MISO al pin 12;• SCK al pin 13 y después a la alimentación.

La librería para el lector RFID se puede descargar desde la dirección https://github.com/miguelbalboa/rfid. Instalad la librería y copiad el sketch:

#include <SPI.h>#include <RFID.h>

#define SDA_PIN 10 #define RESET_PIN 9 RFID RC522(SDA_PIN, RESET_PIN); void setup() Serial.begin(9600); SPI.begin(); RC522.init(); void loop()

230


if (RC522.isCard()) RC522.readCardSerial(); String codice = ""; for(int i = 0; i <= 4; i++) codice += String (RC522.serNum[i],HEX); Serial.println(código); delay(1000);

Gracias a esta librería, el código es muy sencillo: incluís el módulo para RFID y el que se utiliza para la comunicación SPI (Menú Sketch > Import Library > SPI); después definís el módulo RC522 de tipo RFID (el tipo se proporciona en la librería RFID). Al instanciar el módulo, debéis especificar los pines de Arduino conectados a RESET y SDA. En el setup, es preciso inicializar la comunicación SPI y el módulo RFID.La lectura de las etiqueta se ejecuta en el loop(): en primer lugar, se comprueba si exis-te alguna lectura (RC522.isCard()), después, se solicita al lector que adquiera el código que debe ser leído (RC522.serNum[i]) en cuatro ciclos. El código está formado por cua-tro fragmentos que se encuentran en la cadena código. Una vez descargado el sketch, acercáis una etiqueta al lector y leéis el código de la etiqueta en el Serial Monitor.

Tarjetas de memoria SDHe dejado para lo último un apartado dedicado al uso de las tarjetas SD, que no se pueden considerar auténticos sensores, en cuanto son unidades para leer y escribir datos. Son muy útiles pra la creación de proyectos en los cuales se necesita un espacio para memorizar datos. Las tarjetas SD pueden ser utilizadas para escibir logs, es decir, archivos de texto que contienen datos recogidos por Arduino, y pueden memorizar archivos de configuración o archivos con distintas informaciones. El Ethernet Shield y Arduino Yún tienen ambos una slot para tarjeta SD: en estos casos, es muy útil para alojar páginas web si queréis utilizar Arduino como un pequeño servidor. El problema de las tarjetas SD es su duración, relativamente limitada: tras un cierto número de es-crituras, la tarjeta queda inutilizable. A pesar de estas limitaciones, son muy utilizadas y muy cómodas en el caso en que se desee obtener datos registrados para analizarlos en un ordenador.El uso de las tarjetas SD se puede controlar directamente con el protocolo SPI. Existen librerías específicas para facilitar las operaciones de acceso, escritura y lectura de los archivos. Para la conexión del hardware se ha de tener en cuenta que estos dispositi-vos trabajan a 3,3 V. Podéis utilizar chips para adaptar las tensiones entre Arduino y la tarjeta de memoria. La solución más sencilla es el uso de divisores de tensión.

231


Existen múltiples posibilidades de implementación: es habitual encontrar un slot SD en shields como Ethernet Shield o Data Logger Shield; también podéis comprar una tarjeta breakout o podéis conectarla vosotros mismos a Arduino.Conectáis los pines de la tarjeta a Arduino siguiendo el esquema que muestra la Figura 8.26; si utilizáis una tarjeta breakout, podéis unir directamente los pines siguiendo las etiquetas indicadas sobre el circuito impreso. Así es cómo se realiza la conexión directa:

• el pin 10 de Arduino (CS o SS) va conectado al CS de la tarjeta de memoria;• el pin 11 (MOSI), al pin DI de la SD;• el pin 12 (MISO), al pin DO de la SD (¡sin divisor!);• el pin 13 (SCK), al pin SCK de la SD (es el reloj);• GND se coloca junto al periférico;• 3.3V: la alimentación de la tarjeta SD es de 3,3 V, por lo que no la conectéis

a los 5 V.

Utilizando algunas tarjetas como la Ethernet Shield (dotada de lector para SD), ten-dréis que conectar el CS a un pin que no sea el número 10, porque está ocupado por la tarjeta de red. Para configurar el pin CS, debéis especificarlo como parámetro en el método begin() del protocolo SPI:

SD.begin(4);

Figura 8.26 - Conexión de una tarjeta SD a Arduino.

Aseguraos de preparar la tarjeta SD o micro SD formateándola con un formato FAT16 o FAT32. El sistema de archivos será de una tipología una poco anticuada y los archi-vos podrán tener los nombres solo con ocho caracteres, más tres para la extensión.

232


Aquí tenéis un ejemplo de sketch para crear un archivo, escribir datos en él y, por último, leerlo copiando el contenido en el Serial Monitor.

#include <SPI.h>#include <SD.h>

File file;

void setup() Serial.begin(9600); if (!SD.begin(10)) Serial.println("¡Fallo de inicialización!"); return; Serial.println("Inicialización completada.");

file = SD.open("test.txt", FILE_WRITE);

if (file) file.println("Hello!!!!"); file.close(); Serial.println("archivo escrito."); else Serial.println("error al abrir test.txt"); //lettura file = SD.open("test.txt"); if (file) Serial.println("lectura archivo:"); while(file.available()) Serial.write(file.read()); file.close();

void loop()

Antes de empezar, debéis incluir las librerías para la tarjeta SD y para utilizar el pro-tocolo SPI. Definís un objeto File que servirá para leer y escribir en la tarjeta SD. La instrucción SD.begin() puede recibir una serie de parámetros correspondientes a los pines que se utilizan en el puerto SPI. Si utilizáis los pines estándar reservados para la SPI, no es necesario proporcionar ningún parámetro. Si el CS no está en el pin 10, lo indicáis con:

SD.begin(4);

El método begin() devuelve falso si surgen problemas al inicializar la tarjeta de memo-ria. Para crear y abrir un archivo en modo escritura, debéis utilizar SD.open(), propor-cionando el nombre del archivo y el tipo de acceso deseado:

233


file = SD.open("test.txt", FILE_WRITE);

Ahora el objeto File está valorado y preparado para ser utilizado. Para escribir en el archivo, se puede utilizar println() como haríamos para una línea de serie. Al finalizar las operaciones, no os olvidéis de cerrar el archivo con close().

No es posible trabajar en más de un archivo a la vez.

Para la lectura, debéis utilizar open indicando solo el nombre del archivo:

file = SD.open("test.txt");

La lectura del contenido se lleva a cabo comprobando que haya caracteres disponi-bles:

while(file.available())

y después leyendo los datos con:

file.read()

Los bytes leídos aparecerán también en el Serial Monitor.

Otros sensoresEn este capítulo os he presentado una panorámica de los sensores más conocidos y comunes que pueden ser conectados a vuestro Arduino. Como habéis podido ver, las posibilidades son muchas y continuamente aparecen novedades. Existen sensores y dispositivos específicos para entornos especiales, como tarjetas que sirven de inter-faz para sistemas médicos o para detectar determinados tipos de fenómenos. Poste-riormente, podéis ampliar las posibilidades combinando distintos tipos de sensores. Como habéis podido constatar, los datos detectados pueden ser presentados como simples valores analógicos o, en casos más complejos, a través del puerto serie de solo lectura o bidireccional (para configurar el sensor).En cualquier caso, antes de utilizar un sensor, descargad su hoja de especificaciones y recabad toda la información acerca de su uso: controlad los modos de alimentación y de conexión a Arduino y comprobad la existencia de una librería que os pueda facilitar la lectura de las informaciones.

235

Para la mayor parte de los actuadores, las señales de control

son simples impulsos eléctricos que serán transformados en

energía mecánica consumiendo corrientes significa-tivas. Arduino no ha sido diseñado para ser conectado directa-

mente a un motor: es necesario incluir circuitos de control, que pueden ser simples transistores o placas más complejas

controladas por circuitos integrados especializados.

El transistor bipolarLas salidas digitales de Arduino pueden proporcionar como máximo unos diez mi-liamperios a una tensión de 5 V: más que suficientes para encender un LED, pero que no pueden ser utilizados para controlar algo más complicado. En los casos en que sea necesario utilizar corrientes superiores a los 30 o 40 miliamperios, será preciso uti-lizar otros circuitos adecuados. El más simple de estos circuitos de control se puede diseñar con un transistor bipolar.El transistor bipolar (BJT) es un dispositivo con tres terminales creado con tres regio-nes semiconductores dopadas. El funcionamiento puede explicarse mediante electro-nes, huecos, uniones y regiones de agotamiento, describiendo todo ello con algunas fórmulas matemáticas vinculadas a gráficos y tablas. Un transistor no es más que un dispositivo para regular el flujo de una corriente principal, utilizando una pequeña corriente de control.

Actuadores

9

236


Los terminales del transistor se denominan base, emisor y colector. El terminal base funciona como el «mando» de un grifo. Utilizando la analogía hidráulica, el transistor es un grifo conducido por un flujo de agua que controla la válvula principal. En el tran-sistor real, una pequeña corriente puede controlar otra más grande que emana entre colector y emisor, para poder controlar dispositivos que requieren corrientes elevadas, o para amplificar señales débiles.Si no llega corriente a la base, es como si el grifo estuviera cerrado y, por lo tanto, no circula corriente entre emisor y colector. En cuanto llega la mínima corriente a la base (hablamos de microamperios), la vía principal empieza a abrirse. La corriente que circula entre emisor y colector es del orden de varios miliamperios. En el transistor bipolar, la corriente de la base alcanza el flujo principal y se une a él.

Los transistores pueden ser fabricados en distintos formatos, alternando las capas de material semiconductor para obtener la configuración NPN o PNP.El sándwich de semiconductores se recoge en un envoltorio de plástico o metálico: existen distintos paquetes que han sido estandarizados para que tanto la forma como las dimensiones sean definidas de forma precisa. Hay transistores de metal, otros de plástico negro con un borde biselado, otros disponen de una aleta para el enfriamiento (formato TO220), hay otros que aún son metálicos y de grandes dimensiones... ¡lo que nos deja intuir que podrían calentarse mucho (formato TO35)! También existen formatos SMD de montaje superficial, miniaturizados.Prestad atención siempre cuando utilicéis un transistor: aunque los paquetes estén estandarizados, no lo están las disposiciones de los pinouts, que pueden variar de un modelo a otro. Comprobad siempre su disposición consultando las hojas de especifi-caciones (véase la Figura 9.2). Un transistor puede ser utilizado para amplificar señales analógicas: es necesario rea-lizar cálculos bastante complicados y añadir un buen número de componentes pasivos (resistencias y condensadores). Para controlar las cargas, es decir, accionar relé y mo-

Figura 9.1 - Transistores bipolares de tipo NPN y PNP con su símbolo eléctrico.

237

Actuadores Capítulo 9

tores, no es preciso realizar muchos cálculos; por lo general, basta con incluir una o dos resistencias (véase la Figura 9.3).

Conectad un transistor a Arduino como se muestra en la Figura 9.3. El circuito no es muy complicado: la salida digital de Arduino se conecta a la base del transistor de tipo NPN (modelo 2N2222; en la figura se indica el pinout más común, pero podríais utilizar un modelo con un pinout distinto) mediante una resistencia de 1 kiloohm. Para realizar una primera prueba, podéis utilizar un simple LED. Tendréis que crear una «línea» que empieza en 5 V, continua a través del LED y la resistencia de 220 ohms y se conecta al colector del transistor. El emisor está conectado al GND y el transistor puede ser considerado como un interruptor. Cuando la salida de Arduino pasa a nivel alto, llega a la base una corriente de algunos miliamperios, los cuales son más que suficientes para «cerrar» el transistor (técnicamente, se dice que el transistor «está en saturación») y después encender el LED.Cuando la salida digital de Arduino está a nivel bajo, no circula corriente y la base está colocada a 0 V. El transistor está en corte y el LED se enciende.Como sketch podéis utilizar el código Blink y conectar la base del transistor al pin 13.

Figura 9.2 - Varios modelos de transistor.

Figura 9.3 - Arduino conectado a un transistor que controla un LED.

238


Controlar un reléEl relé es un dispositivo electromecánico que sirve para controlar un interruptor o un desviador formado por uno o más contactos utilizando un electroimán. La bobina uti-lizada como electroimán requiere corrientes de unas decenas de miliamperios (qui-zás, un centenar). El relé puede conectarse a un electrodoméstico para encenderlo o apagarlo a distancia.

NO

TA

Estad muy atentos cuando trabajéis con la tensión de red: una descarga eléctrica puede ser mortal. No trabajéis nunca con aparatos o circuitos conectados a la corriente y, si no sois expertos o en caso de duda, pedid ayuda a un profesional.

La conexión del relé es completamente igual al que se realiza para el LED. Si utilizáis un relé con tensión de activación de 5 V, no es necesario poner en serie con la bobina una resistencia; si no, no tendréis suficiente tensión para accionarlo. Debéis tener en cuenta que el transistor, cuando está en saturación, no se puede comparar con un interruptor «perfecto» y, por tanto, robará alguna fracción de voltio al circuito: en los extremos del relé podríais encontrar 4,8 V en lugar de 5, que, por otra parte, son sufi-cientes para hacerlo funcionar. Si el relé no funciona, podéis intentar disminuir el valor de la resistencia conectada a la base hasta unos cien ohms, como máximo. En paralelo a la bobina, es preciso añadir un diodo de protección para evitar que, cuando el relé se relaje, circulen corrientes de Foucault en sentido inverso y dañen el transistor.

Figura 9.4 - Arduino conectado a un relé, con detalle del transistor 2N2222 y de la conexión del diodo al relé.

239


En alguna ocasión, quizás tengáis que utilizar un relé a 12 V (o a un voltaje distinto a los 5 V de Arduino). No hay ningún problema si se siguen unas reglas sencillas:

• mantener separadas entre ellas las distintas alimentaciones (nunca unir los 5 V de Arduino con los 12 que solicita el relé);

• juntar las masas (es decir, el GND de Arduino con el negativo de alimentación de los 12 V necesarios para el relé).

Seguid las indicaciones de la Figura 9.5, en la cual se muestra el circuito con el relé y la alimentación de 12 V. En la imagen, Arduino está alimentado mediante un cable USB conectado a un ordenador o a un alimentador USB.

Figura 9.5 - Uso de un relé a 12 V con Arduino y una doble alimentación.

Es posible alimentarlo todo con una única fuente de alimentación de 12 V: el regulador interno de 5 V de Arduino disminuirá la tensión y los 12 V serán accesibles para el pin VIN. Para alimentar a Arduino, tendréis que conectar al puerto de alimentación de este último una fuente de alimentación con una tensión mayor a 5 V (en este caso, deben ser como mínimo 12 V)25 (véase la Figura 9.6).Del mismo modo que habéis conectado un relé, podéis conectar cualquier otro dis-positivo que requiera corrientes «elevadas» (es decir, mayores que 10 miliamperios) y eventualmente una tensión distinta, como podrían ser lámparas incandescentes, ban-das de LED de alta luminosidad o motores con corriente continua.

25 La fuente de alimentación externa debe tener una tensión comprendida entre 5 y 12 V. Es posible llegar a una veintena de V, pero el regulador de tensión de Arduino se calentará muchísimo.

240


Relés especialesA veces, ni los relés normales bastan para activar un contacto, lo que podría daros problemas debidos a interferencias electromagnéticas o picos de corriente. La pre-sencia de este tipo de interferencias comporta el réset no deseado e impredecible del microcontrolador. Algunos dispositivos, como algunas bombas o ciertos modelos de motor eléctrico, pueden necesitar señales más altas y generar arcos eléctricos en el momento de la separación de los contactos del relé. Podéis solventar el problema utilizando un relé de estado sólido, que no utiliza un sistema electromecánico para las conmutaciones. Estos componentes son de tamaño muy reducido y costes en general superiores a los de los relés comunes.Para conmutar una carga alimentada mediante la tensión de red, se puede utilizar un TRIAC, una especie de transistor que funciona como interruptor para la corriente alterna. Normalmente, el TRIAC no está controlado por el microcontrolador, sino que utiliza un op-toacoplador para separar completamente el circuito de control del controlado, alimentado a 220 V. Prestad mucha atención cuando fabriquéis este tipo de circuitos y evitad cons-truirlos solos si no sois expertos. En caso de duda, comprad placas breakout prefabricadas.

¡Un incidente con la tensión de red a 220 V puede ser mortal!

A título orientativo, muestro a continuación el esquema de conexión de un TRIAC a Arduino mediante un fotoacoplador. Para mejorar posteriormente la conmutación, es posible utilizar un fotoacoplador de cruce por cero, que espera el momento más adecuado para conmutar el circuito, es decir, cuando la tensión alterna, en su ciclo, llega a 0 V. Las descargas entre los contactos del relé se comprueban cuando el relé se separa en el momento en que la tensión llega a su máximo.

Figura 9.6 - Relé a 12 V con ali-mentación individual.

241


Un modelo de fotoacoplador de cruce por cero para el control de un TRIAC es el BRT21. Como TRIAC se puede utilizar un BTA08-400. La sigla del TRIAC depende del fabricante: a veces es «elocuente» y permite saber de inmediato que el dispositivo puede trabajar a hasta 8 amperios con tensiones de 400 V.

Figura 9.7 - Esquema de conexión de un TRIAC con optoacoplador de cruce por cero.

Los transistores MOSFETAdemás de los transistores bipolares NPN y PNP, existen otros modelos de transis-tores denominados FET, obtenidos de la combinación de materiales semiconductores de forma distinta a los transistores bipolares. Los FET tienen un canal principal en el cual fluye la corriente con dos piezas de inserción en la parte central, realizadas con un semiconductor de tipo opuesto que forma una unión PN y que, por tanto, se comporta como un diodo. Por esta razón, los transistores construidos con esta tecnología se denominan también J-FET, es decir, Junction-FET («de unión», porque contienen una unión PN). Cuando la unión PN está polarizada inversamente, puede limitar o impedir el paso de la corriente en el canal principal.Las diferencias con el transistor bipolar son las siguientes:

• los terminales se denominan drain, source y gate. El gate es el terminal de control;• el FET es un dispositivo controlado por una tensión aplicada al gate y no por una

corriente;• la corriente circula entre el drain y el source aunque no se aplique tensión al gate,

porque no encuentra ningún obstáculo;• el gate prácticamente no absorbe corriente (algún picoamperio);• si se utiliza como amplificador, no amplifica mucho, pero no absorbe corrien-

tes de los dispositivos que conectamos a la entrada (resulta óptimo en el caso de señales muy débiles).

Existen FET de tipo P o de tipo N, según el material utilizado en el canal principal.Los transistores MOSFET pertenecen a la familia de los transistores FET y tienen tres terminales denominados gate, source e drain. Aplicando una tensión al gate, es posi-ble controlar la corriente que circula en el semiconductor conectado a drain y source

242


(denominado también «canal»). A través del gate de los transistores J-FET pasa una corriente muy pequeña (de algunos picoamperios), pero en los MOSFET esta corrien-te es todavía más pequeña: presentan una resistencia de entrada de unos 1014 ohms.El gate de los MOSFET está electricamente aislado del canal entre el drain y el source y forma una especie de condensador. Por este motivo, son muy sensibles a la electrici-dad estática y deben manipularse con precaución para evitar dañarlos con un simple toque. Como precaución, podemos utilizar brazaletes especiales antiestáticos que se conectan con un cable a una toma de tierra: un grifo, un radiador o cualquier toma de tierra de casa. También puede ir bien un armario metálico grande.Existen dos tecnologías de fabricación denominadas enhancement y depletion. Cada una de ellas cuenta con dos variantes: de canal N o de canal P.

El MOSFET como interruptorEl uso más simple de un transistor MOSFET es como interruptor controlado por una tensión. Probemos a hacer un experimento utilizando un MOSFET enhancement de canal N, como el 2N7000 o un IRF520. Para controlar el dispositivo, es necesario tra-bajar sobre la tensión VGS, es decir, la diferencia entre gate y source.

Motores eléctricos

Un motor eléctrico transforma la energía eléctrica en energía mecánica. Está for-mado por imanes y electroimanes que requieren corrientes de cierta intensidad para funcionar. Los motores de corriente continua (CC) contienen dos elementos denominados estátor y rotor. La parte en movimiento, el rotor, es un electroimán, mientras que el estátor es un imán permanente integral con el cuerpo del motor. El principio que se utiliza es el de los imanes que se atraen o se repelen según su orientación. Un sistema de cepillado alimenta el rotor para que siempre se en-cuentre en contraste con el estátor y, por tanto, exista repulsión entre ambos: esta condición le permite rotar. Los cepillos tocan una serie de contactos que magne-tizan el rotor con polaridades alternas. Con este ingenioso mecanismo, el motor se alimenta con una simple corriente continua. Los motores brushless no tienen contactos «deslizantes» y el movimiento se produce gracias a una serie de elec-troimanes activados en secuencia. Para regular la velocidad de los motores en CC, no podemos simplemente modificar la tensión y la corriente de funcionamiento: el motor requiere una tensión y una corriente muy precisas.

243


La regulación se lleva a cabo aplicando una señal de tipo PWM que enciende y apaga el motor muchas veces en un segundo, obteniendo la velocidad deseada.

En los motores paso a paso, el rotor no gira libremente, sino que ejecuta un paso (step) cada vez, controlado por una serie de electroimanes conectados entre ellos. Para que el eje del motor rote, es necesario alimentar los grupos de electroimanes en la secuencia correcta. Estos motores se reconocen porque tienen cuatro, seis u ocho cables de alimentación. Para activarlos, es preferible utilizar un circuito de control (driver) que se ocupe del encendido de los electroimanes. Los motores paso a paso se utilizan mucho en robótica y automatización industrial porque son precisos: la rotación mínima puede ser incluso de fracciones de grado.

Realizad el circuito mostrado en la Figura 9.8: el pin 13 de Arduino se conecta a un LED utilizando un MOSFET 2N7000. Para probar el circuito, cargad el sketch Blink que hace parpadear el pin 13 a intervalos de un segundo. El pin 13 está conectado al gate del MOSFET, el drain está conectado al GND y el source, al LED y la resistencia. Cuando se aplican 5 V al gate, el transistor está en conducción permitiendo que el LED se encienda, porque la tensión en el gate es precisamente de 5 V y la del source es al menos 2 V inferior, por lo que VGS es como mínimo igual a 2 V: suficiente para activar el MOSFET. Cuando el gate está a 0 V, la VGS es negativa y el transistor no conduce.En algunos esquemas, se puede encontrar una resistencia de valor muy elevado (por ejemplo, un megaohm) entre el gate y el circuito de control: el resistor de un megaohm sirve para compensar corrientes parásitas que podrían volver el transistor inestable. Cuando el resistor está conectado a tierra, a través del mismo no fluye corriente o pasa muy poca, por lo que el gate se puede mantener a 0 V. En el esquema de la Figura

Figura 9.8 - Un motor en CC y un motor paso a paso con sus símbolos eléctricos.

244


9.9 se ha añadido una resistencia de 10 kiloohmios para mantener el gate a 0 V y con-seguir que el MOSFET sea más estable.

Figura 9.9 - Esquema de conexión de un MOSFET a Arduino. A la izquierda, el MOFSET con el símbolo oficial y la versión abreviada (formalmente incorrecta, pero fácil de diseñar).

MOSFET logic levelHace tiempo, un artista me pidió que le hiciera una instalación formada por decenas de lámparas halógenas de 12 V, controladas por señales PWM. Creé una placa de control con Arduino Mega y treinta y dos MOSFET IRF520, pero mi cliente no estaba del todo convencido de la luminosidad de las lámparas: se encendían pero no como él quería. En cierta manera, tenía razón: las lámparas se alimentaban con 12 V, mien-tras que el MOSFET estaba controlado por una tensión máxima de 5. Para alcanzar la máxima luminosidad, debería haber usado tensiones de gate de 12 V. ¿Qué podía hacer? No tenía tiempo de rediseñar todo el circuito. La solución fue sustituir todos los MOSFET con modelos de tipo «logic level», sin modificar nada más.Así es, para controlar un dispositivo que necesita una alimentación distinta a la ten-sión máxima que podemos aplicar al gate, es necesario utilizar un MOSFET logic level. La situación típica es aquella en que, con Arduino, queremos controlar el encendido de una lámpara o de una banda de LEDs de 12 V. Arduino controla las lámparas me-diante un MOSFET que acciona con una señal que, como máximo, alcanza los 5 V. En estos casos, el canal MOSFET no está completamente «abierto» y presentará una cierta resistencia: las lámparas no se encenderán con la máxima luminosidad. Debéis utilizar un MOSFET logic level para alcanzar la máxima apertura, incluso si se aplica al gate una señal de solo 5 V. El MOSFET FQP30N06L es un dispositivo logic level en-hancement de tipo N. El aspecto exterior de estos componentes es idéntico al de los MOSFET convencionales; a veces incluso presentan pinouts compatibles.

245


Figura 9.10 - Con un MOSFET logic level es posible controlar cargas alimentadas con tensiones distintas a 5 V.

Controlar un motor con MOSFETUn uso habitual de los MOSFET es para controlar un motor eléctrico en corriente continua, que requiere una corriente que Arduino no puede proporcionar y, a veces, incluso tensiones distintas. Utilizando el MOSFET, es posible regular la velocidad del motor con una señal PWM que enciende y apaga el motor muchas veces por segun-do. El esquema de conexión es similar al que se utiliza para el LED de la Figura 9.9. La resistencia de 10 kiloohms sirve para mantener el gate «anclado» al GND y ofrecer una mayor estabilidad al circuito. El motor eléctrico genera corrientes parásitas y no deseadas que pueden dañar el transistor de control; por esa razón, a los extremos del motor se conecta un diodo (por ejemplo, un 1N4007 o un 1N4005) para anularlas. El gate se conecta a un pin PWM (por ejemplo, el pin número 9). Para probar el circuito, descargad el sketch Basics -> Fade: oiréis cómo el motor acelera y frena progresiva-mente. El motor utilizado se alimenta con los 5 V que toma de Arduino.

Figura 9.11 - Esquema de conexión de un motor con MOSFET y control en PWM.

246


Controlar un motor paso a pasoControlar un motor paso a paso es una cuestión más compleja. Es posible aplicar el esquema de la Figura 9.11 y alimentar directamente con Arduino los distintos deva-nados, pero vuestro microcontrolador no tendrá tiempo ni recursos para hacer nada más. Las señales de control de un motor de este tipo son complejas y deben consi-derarse muy variables. Es mejor dejar que realice este trabajo una placa especial: un driver para motores paso a paso que gestionará todas las señales y simplificará la tarea del control.Existen distintos modelos de placas breakout con driver para motores paso a paso, como las Pololu A4988, que cuestan menos de diez euros y se pueden utilizar con motores de tipo bipolar. Para controlar el motor se necesitan solo tres comandos (tres pines):

• ENABLE – para activar o desactivar el motor;• STEP – cada impulso recibido en esta línea ejecuta un paso del motor;• DIR – su estado corresponde a la dirección de rotación del motor.

Si mantenéis el motor siempre activado, solo necesitaréis dos «cables» para contro-larlo. Es posible modificar también la longitud del paso desde los pines MS1, MS2 y MS3. Si se dejan desconectados, el paso será “entero”, pero aplicando señales a estas líneas, es posible reducir el paso hasta ocho veces.El motor está alimentado mediante una fuente independiente que puede llegar hasta unos 35 V. En el lado superior de la breakout hay un pequeño chip que, durante el funcionamiento, puede calentarse mucho: por ello, junto a la placa encontraréis un pequeño disipador térmico para aplicar al chip.Del motor paso a paso salen cuatro cables que deben conectarse a los pines 1A-1B y 2A-2B de la placa. Para saber cómo realizar esta conexión, debéis consultar la hoja de especificaciones técnicas, o bien probar de identificar con la ayuda de un tester los cables que pertenecen a la misma bobina. La primera bobina se conecta al par 1A-1B, mientras que la segunda se conecta a 2A-2B. Si se invierten los pares, no pasa nada. Para la placa Pololu, es preciso añadir un condensador de 100 microfaradios entre las dos líneas de alimentación.

No conectéis ni desconectéis nunca el motor mientras la placa está conectada a la corriente: la podríais dañar irremediablemente.

El sketch para controlarla es muy sencillo: os cedo la tarea de escribirlo y cargarlo. Para dar los impulsos de los pasos podéis utilizar el sketch Blink, reduciendo los tiempos de pausa a unos cien milisegundos. Agregad una señal para controlar la dirección del motor.

247


Figura 9.12 - Uso de una placa de control para motores paso a paso.

Salidas optoaisladasEn el Capítulo 8 he presentado los optoaisladores. Estos dispositivos pueden ser apli-cados también a las salidas de vuestros circuitos para aislar completamente Ardui-no de aquello que queréis controlar. Resultan muy útiles para separar circuitos con alimentaciones distintas y en el caso del control de dispositivos ruidosos. Habitual-mente, para controlar un motor alimentado a 12 V, se utiliza un transistor de control y un alimentador que debe tener la msa (GND) en común con el microcontrolador. De esta forma, disponéis de dos circuitos con características diferentes y conexio-nes eléctricas comunes. Si el motor produce muchas interferencias eléctricas que se propagan hacia el microcontrolador, podéis identificar situaciones anómalas, como resets o comportamientos extraños. Para evitar todo esto, insertad un optoaislador y separad electrónicamente los dos circuitos: no es la única precaución a tomar, pero ayuda mucho. Un optoaislador muy común es el modelo 4N25. En este caso, Arduino controla el LED interno, mientras que el «lado» del fototransistor estará conectado al circuito a controlar.

Figura 9.13 - Salida optoaislada con 4N25 y conectada a una lámpara alimentada con 12 V.

248


Potenciómetros digitalesEn ocasiones, sería realmente cómodo poder controlar el valor de una resistencia me-diante nuestro sketch.La cuestión es casi tan sencilla como accionar un relé: se puede utilizar un chip espe-cial denominado potenciómetro digital que en su interior tiene una serie de resistencias que simulan el efecto de un potenciómetro o un trimmer. Es como si Arduino pudiera intervenir en la regulación de un trimmer o de un potenciómetro. Existen varios chips que utilizan distintas técnicas de control: algunos se controlan mediante una línea de serie y otros, con simples bits. Algunos chips están dotados de memoria y recuerdan la última configuración, incluso cuando están apagados. El valor de la resistencia glo-bal que es posible controlar puede ser seleccionado entre una gama de valores habi-tualmente bastante limitados (por ejemplo, 10, 50 y 100 kiloohms).Un chip muy fácil de usar es el modelo DS1804 de Maxim, un pequeño chip con ocho pinouts que se controla con dos únicos pines: uno controla la dirección y el otro «efectúa un paso». Este potenciómetro tiene una memoria por el valor configurado y está dispo-nible en tres variantes de 10, 50 y 100 kiloohms, con las siglas DS1804-010, DS1804-050 y DS1804-100, respectivamente. El número total de divisiones y, por tanto, de re-gulaciones ajustables es de 100. Para activar el chip, es necesario alimentarlo con una tensión comprendida entre los 3 y los 5 V y poner a nivel bajo el pin CS (Chip Select). Los terminales de trimmer están marcados como H, L y W: el pin central corresponde al pin marcado con la letra W. Una limitación de este componente es que no es posible aplicar al potenciómetro tensiones inferiores o superiores a las de alimentación, por lo que es necesario mantenerse en el rango entre 0 y la máxima tensión de alimentación.

Figura 9.14 - Uso de un potenciómetro digital con Arduino.

Para controlar el chip basta con conectar los pines CS, INC y UD a Arduino. Para con-trolar un paso, se debe bajar el INC, configurar el UD (HIGH para aumentar el valor de

249


la resistencia y LOW para disminuirlo) y después volver a subir el INC al finalizar la ope-ración. Las secuencias de control se recogen en dos funciones denominadas stepup() y stepdown(). Este es el sketch de control:

#define CS 12#define UD 11#define INC 10

void setup() pinMode(CS, OUTPUT); pinMode(UD, OUTPUT); pinMode(INC, OUTPUT); //activo el chip digitalWrite(CS, LOW); Serial.begin(9600);

void loop() for (int i = 0; i < 100; i++) stepup(); delay(200); Serial.begin(analogRead(A0)); for (int i = 0; i < 100; i++) stepdown(); delay(200); Serial.begin(analogRead(A0));

void stepup() digitalWrite(INC, LOW); digitalWrite(UD, HIGH); digitalWrite(INC, HIGH);

void stepdown() digitalWrite(INC, LOW); digitalWrite(UD, LOW); digitalWrite(INC, HIGH);

Los terminales del potenciómetro han sido conectados a la alimentación a 5 V, para que, al conectar el pin W a A0, sea posible leer la tensión configurada. El valor detec-tado se muestra en el Serial Monitor.Un potenciómetro digital más complejo es el MCP41xxx o MCP42xxx (como poten-ciómetro individual o doble), con control de serie mediante un puerto SPI. Para el con-trol es necesario enviar a la línea de serie el valor que se desea configurar. Este poten-ciómetro tiene una memoria interna, está dividido en 256 pasos (en lugar de 100) y está disponible en tres valores (10, 50 y 100 kiloohms). El modelo MCP41010 es un potenciómetro individual digital de 10 kiloohms. Para controlarlo, es aconsejable utili-

250


zar la librería SPI de Arduino, que simplifica mucho las operaciones de comunicación (evita tener que traficar con bits individuales).

Conectar un DACArduino Uno puede leer señales analógicas pero no puede generarlas, por lo que puede ser de gran ayuda contar con un sistema que se ocupe de ello. Es posible generar señales analógicas con un convertidor digital-analógico, un circuito integrado que recibe núme-ros y los transforma en una tensión comprendida entre un valor mínimo y otro máximo.Arduino Due y Arduino Zero incluyen de origen salidas analógicas:

• dos salidas DAC de 12 bits en Arduino Due;• una salida DAC de 10 bits para Arduino Zero.

El número de bits indica la precisión que puede obtener el DAC: cuanto mayor sea el número de bits, mayor será el número de pasos en que se subdividirá la tensión utili-zada para generar la señal analógica.Para utilizar los pines DAC en Arduino Due, basta con usar analogWrite() especifican-do el pin DAC0 o DAC1 (A0 en Arduino Zero) y el valor deseado. En Arduino Due, el valor configurado puede llegar hasta 4095, mientras que en Arduino Zero el valor máximo es de 1023. Así es cómo se configura un valor analógico de salida:

analogWrite(DAC0, 2345);

La precisión del DAC puede ser regulada con analogWriteResolution(bit), indicando el máximo valor de bits que se debe utilizar. La función actúa sobre todo el código de Arduino y normalmente se configura en 8 bits. Modificad el número de bits (hasta el valor máximo para aumentar la precisión) antes de generar una señal analógica y después lo volvéis a configurar, esta vez a 8 bits, para no trastocar el funcionamiento de las salidas PWM.

analogWriteResolution(12);

Con Arduino Uno, podéis generar señales analógicas conectando un chip DAC ex-terno. Existen múltiples circuitos que se pueden utilizar, con distintas interfaces de control: I2C, SPI y paralelos.El Motorola MCP 4725 es un DAC de 12 bits con interfaz I2C. Puede encontrarse premontado en una placa breakout y existen librerías para utilizarlo de manera muy sencilla. Podréis crear señales de audio mejores que las ondas cuadradas producidas por los PWM y por la función tone(). El chip se controla utilizando dos únicas cone-xiones (SEDA y SCL) y se alimenta a 5 o 3 V. La librería de control se puede descargar desde GitHub (http://bit.ly/MCP4725).

251


Para funcionar, la librería requiere Wire.h, que debe incluirse al inicio del sketch. Se crea un objeto dac de tipo Adafruit_MCP4725 y se inicializa proporcionando su direc-ción, que por norma es 0x62. Para ajustar un valor en el DAC, se utiliza setVoltage() indicando un número del 0 al 4095. El segundo parámetro sirve para guardar el valor configurado en la memoria interna EEPROM del chip, de manera que cuando vuelva a encenderse encontréis la tensión guardada. No abuséis de esta función porque es posible realizar solo 20.000 almacenamientos.

#include <Wire.h>#include <Adafruit_MCP4725.h>

Adafruit_MCP4725 dac;

void setup(void) dac.begin(0x62);

void loop(void) for (int i = 0; i < 4095; i++) dac.setVoltage(i, false);

Salida de audioAunque Arduino solo puede producir sonidos crepitantes con las ondas cuadradas de los PWM, quizás os podría interesar ampliar estas señales. Podéis conectar un pin de salida a un amplificador, pero es necesario tomar ciertas precauciones. La señal pro-ducida por las salidas digitales es una tensión que vale 0 o 5 V, y no es muy agradable aplicar directamente 5 V a la entrada de un delicado amplificador de audio. Por esta razón, es buena idea crear un divisor de tensión del cual extraer la señal mediante un condensador que separará las señales de manera adecuada.

Figura 9.15 - Uso del DAC 4725.

252


Otros actuadoresEn este capítulo habéis aprendido a conectar distintos tipos de actuadores a Arduino, mediante distintas técnicas, como el uso de transistores bipolares o MOSFET. Habéis aprendido a conectar un driver para motores paso a paso y a controlar algunos dispo-sitivos utilizando los puertos serie.Existen aún infinitas posibilidades, pero los sistemas de conexión y comunicación al final recaen en pocas categorías. Cuando os encontréis frente a un nuevo dispositivo, en primer lugar controlad su hoja de especificaciones y después comprobad en Inter-net si existen ejemplos para Arduino.

Figura 9.16 - Circuito para conectar Arduino a un amplificador de audio.

253

Vuestros proyectos serán mucho más interesantes cuando

puedan conectarse con otros dispositivos remotos

e intercambiar informaciones. Utilizando las capaci-

dades nativas de Arduino, y en ocasiones añadiendo placas o

shields, podréis transmitir y recibir por distintos canales están-

dar, como los puertos serie e, incluso, por Internet.

Un poco de teoríaLas comunicaciones, no solo en el ámbito de la electrónica, requieren elementos fun-damentales:

• un transmisor que tenga algo que decir;• el mensaje;• un receptor que esté interesado en escuchar;• un canal de transmisión con interferencias;• una convención preestablecida entre el que transmite y el que recibe.

Estos elementos son necesarios tanto si se transmiten mensajes mediante banderas náuticas como si se transfieren archivos por Internet.En la era digital, transmitir información significa transferir bits de un transmisor a un receptor. La unidad más pequeña de información es el bit, por lo que una cierta transmisión será más o menos rápida según cuántos bits por segundo sea capaz de transmitir. Por una serie de razones relacionadas con la recuperación de errores y para

Comunicarse

10

254


aumentar la eficiencia de una línea de transmisión, se prefiere transmitir símbolos en lugar de bits individuales. Un símbolo es simplemente un conjunto de bits. Para trans-mitir simples bits por una línea eléctrica, podéis aplicarles 5 V si queréis transmitir un “1” y 0 V, para un “0”. Para agilizar las cosas, podríais transmitir 2 bits a la vez, para lo cual tendríais cuatro posibilidades, es decir, cuatro símbolos: “00”, “01”, “10” y “11”. ¿Cómo lo haremos para transmitirlos? Podríais asociar a cada par una tensión distin-ta, como se indica en la Tabla 10.1.

Tabla 10.1 - Distintas tensiones corresponden a pares de bits.

Par o símbolo Tensión (V)

00 +5,001 +2,510 -2,511 -5,0

Así, transmitís 2 bits a la vez y podéis hablar de símbolos por segundo, también deno-minados baudios. Se puede complicar el sistema y transmitir más bits, añadiendo más niveles de tensión. Este método, aun siendo muy intuitivo, es bastante problemático porque es muy vulnerable a las interferencias. Para mejorar la eficiencia y crear sistemas de transmisión mejores, se utilizan las modulaciones: el bit puede estar asociado a una determinada frecuencia (y, por tanto, a una nota). El receptor se complica, pero de este modo es posible transmitir una mayor cantidad de información en poco tiempo. Las mo-dulaciones posibles son: en amplitud, en frecuencia y de la fase de una señal.La modulación de la amplitud utiliza un portador que se combina con la señal a trans-mitir. Una secuencia de bits se transmitirá con un «tren» de impulsos de frecuencia fija (un poco como el código Morse).En la modulación de la frecuencia se modifica precisamente la frecuencia del porta-dor y, para transmitir una serie de bits, contáis con una nota que «pita», es decir, que modifica rápidamente su frecuencia según si lo que se transmite es un “1” o un “0”.La modulación de la fase es más complicada, pues actúa en el punto inicial de la nota.

Figura 10.1 - Transmisión de bits de modulación de la amplitud (AM), de la frecuencia (FM) y de fase.

255

Comunicarse Capítulo 10

Cualquier transmisión se lleva a cabo utilizando un canal que puede ser, por ejemplo, un cable eléctrico, una fibra óptica o el éter. Todos los canales están afectados por interferencias que molestan a la transmisión y, si son excesivas, es difícil la recupe-ración de la información por parte del receptor. Para proteger las transmisiones de las interferencias se utilizan distintos sistemas, desde los más sencillos, que utilizan repetidores de señales, a los más complejos, de tipo digital, que utilizan códigos de control adicionales a las informaciones transmitidas para saber si los datos recibidos han sido dañados. Estos códigos, en algunos casos, pueden incluso corregir el error automáticamente.En el mundo de la electrónica digital, es posible transmitir informaciones utilizando una o diversas líneas. Las transmisiones paralelas son más simples y permiten alcan-zar velocidades más elevadas, puesto que es posible transferir más bits de una sola vez, aunque ocupan muchas líneas y, actualmente, con procesadores de 16, 32 y 64 bits, el número de cables necesarios crece excesivamente. En las transmisiones por serie, se utiliza un único cable en el cual se acoplan, uno a uno, los bits que hay que transmitir y recibir utilizando el menor número de cables y para sincronizar de alguna manera transmisor y receptor. Las distintas soluciones han generado diferentes pro-tocolos y estándares de comunicación.Trabajando con Arduino y con la electrónica, a menudo tendréis que manejar el nivel más bajo de las transmisiones y, por tanto, tendréis que tratar de gestionar señales eléctricas y temporizaciones. Sin embargo, la mayoría de las veces hay alguien que ya ha desarrollado este trabajo que, más tarde, ha puesto a disposición de la comunidad mediante prácticas librerías.

Puertos serieTodas las placas Arduino tienen como mínimo un puerto serie de tipo UART26 para comunicarse con vuestro ordenador y con todos los dispositivos que soportan este tipo de intercambio de datos. El puerto serie de Arduino tiene dos líneas denominadas RX y TX, que corresponden a los pines 0 y 1 y es accesible utilizando el objeto Serial. Arduino Mega y Arduino Due disponen de otros tres puertos serie:

• Serial1 – RX en el pin 19 y TX en el pin 18;• Serial2 – RX en el pin 17 y TX en el pin 16;• Serial2 – RX en el pin 15 y TX en el pin 14.

Prestad atención si utilizáis Arduino Due puesto que trabaja a 3,3 V y, si se conecta a dispositivos alimentados a 5 V, podríais dañarlo.

26 Universal Asynchronous Receiver-Transmitter, es decir, «Transmisor-Receptor Asíncrono Univer-sal».

256


Podéis utilizar Serial para enviar datos a vuestro ordenador y leerlos en el Serial Moni-tor, o para comunicaros con otros dispositivos, prestando atención en cruzar las líneas para la conexión: el TX del transmisor va en el RX del receptor y viceversa.

Al abrir el Serial Monitor, debéis comprobar si habéis ajustado la misma velocidad asignada al puerto; si no, no conseguiréis leer correctamente los datos enviados. Cada vez que conectéis el Serial Monitor a una placa Arduino Uno (o Mega), la placa se reseteará. Tenedlo en cuenta para evitar desagradables inconvenientes.Para activar la comunicación, utilizad la instrucción begin(), pasándole como paráme-tro la velocidad de comunicación deseada:

Serial.begin(9600);

La velocidad se expresa en baudios y los valores que se suelen utilizar son: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. Con begin() podéis confi-gurar parámetros adicionales para ajustar el puerto, aunque esta operación no es de-masiado habitual. Podéis especificar los valores para los bits de paridad y de parada. Las configuraciones predeterminadas utilizan 8 bits para los datos, ninguna paridad y 1 bit de parada:

Serial.begin(9600, SERIAL_8N1);

Para más información acerca de los parámetros disponibles, consultad el manual onli-ne (https://www.arduino.cc/en/Serial/Begin).Cuando un sketch de Arduino utiliza la instrucción:

Serial.println("Hello World!");

en el Serial Monitor aparecerá el texto "Hello World!". Además de println() existen otros métodos que podéis utilizar pra escribir datos: println añade automáticamente

Figura 10.2 - Para conectar dos dispositivos con el puerto serie, debéis cruzar las líneas.

257


un retorno de carro después de cada mensaje enviado. Para escribir algo sin que se añada un retorno de carro, utilizad:

Serial.print("hel");Serial.print("lo");

Si queréis controlar la inserción de una nueva línea, utilizad el carácter \n. Para añadir una tabulación e imprimir los datos en orden, utilizad \t. Para mostrar una variable con descripciones, es necesario utilizar una serie de print() y println(). Por ejemplo, para mostrar "x: " seguido del valor de la variable x debéis escribir:

Serial.print("x: ");Serial.println(x);

No es posible combinar más de una variable en la misma «impresión» a menos que se utilice sprintf() para preparar la cadena que hay que enviar a println(). Tendréis que crear una variable con una longitud que pueda contener el texto formateado. Este sería un ejemplo para mostrar las coordenadas de un punto:

int x = 12;int y = 33;int z = 45;char str[16];sprintf(str, "x: %d y: %d z: %d \n", x, y, z);Serial.print(str);

Serial dispone también del método write() para enviar bytes en lugar de caracteres:

Serial.write(12);

Si se envía 12 con write(), no aparecerá nada en el Serial Monitor, porque no existe ningún carácter que corresponda a dicho número. El Serial Monitor intenta convertir los bytes que recibe en caracteres ASCII. En cambio, si escribís:

Serial.write(65);

aparecerá una A mayúscula. Los métodos print() y println(), en cambio, muestran cualquier número sin problemas, porque lo transforman en caracteres imprimibles. El método write() acepta también caracteres y cadenas y devuelve el número de bytes impresos:

Serial.write("Hello");int wri = Serial.write("Hello", 3);

258


Para transferir matrices (array) de bytes, es necesario indicar siempre la longitud de dicha matriz, especificando el número de elementos o utilizando el cómodo operador sizeof():

byte buf[5] = 65,66,67,68,69;Serial.write(buf, 5);Serial.write(buf, sizeof(buf));

Los puertos serie de Arduino también pueden recibir datos. Para ajustar la recepción de datos, sencillamente debéis configurar el puerto serie con begin() y después estar atentos por si se recibe algún byte. La recepción es un proceso continuo que se ges-tiona en el loop() del sketch. El método available() avisa si llegan bytes a la línea de serie que se puedan leer llamando la función read(). El puerto serie tiene un búfer de 64 bytes en el cual se inscriben los datos recibidos antes de ser leídos. Aquí tenéis un ejemplo para controlar un LED conectado al pin 13 enviando una a o una s utilizando el Serial Monitor:


void loop() while(Serial.available() > 0) char ch = Serial.read(); if (ch == 'a') digitalWrite(13, HIGH); if (ch == 's') digitalWrite(13, LOW);

Dentro del loop() hay un ciclo while() para la lectura del puerto serie que controla constantemente si hay datos disponibles con Serial.available(). En cuanto llegan ca-racteres, estos se extraen del búfer con read(). Si el carácter recibido es una a, la salida 13 pasa al nivel alto; si el carácter recibido es una s, el pin asume el valor LOW y el LED se apaga.Para enviar caracteres mediante el Serial Monitor, estos se escriben en el campo de texto de la parte superior de la ventana y después se pulsa el botón Send.La versión 1.6.6 de Arduino incluye un nuevo instrumento, el Serial Plotter (véase la Figura 10.3), con el cual podéis trazar inmediatamente un gráfico enviando números a vuestro ordenador con una Serial.println(). El gráfico se adapta automáticamente a los valores recibidos.

259


Figura 10.3 - El nuevo Serial Plotter de Arduino.

Software SerialEn ocasiones, necesitaréis utilizar un puerto serie adicional, pero el hardware de Ar-duino solo dispone de uno. En otras, en cambio, podría ocurrir que quisiérais trans-ferir vuestro sketch en un chip distinto, por ejemplo, un ATtiny, para reducir costes y tamaño, pero que desafortunadamente no siempre tiene un puerto UART. Es posible simular un puerto serie completamente mediante software. La librería se incluye en el IDE de Arduino y deriva de un proyecto de Mikal Hart. Utilizando esta solución, es posible crear un puerto para comunicar hasta 115.200 baudios. Es posible crear más puertos serie, pero solo uno a la vez puede recibir datos.Os propongo una sencilla prueba que requiere dos placas Arduino. Yo he utilizado una placa Arduino Uno como transmisor y he cargado un sencillo sketch que aumenta un contador cada medio segundo y transmite el dato al puerto serie.Este es el sketch:


int count = 0;

void loop() Serial.println(count); delay(500); count++;

260


Seguidamente, en una segunda placa, he cargado un sketch que utiliza el puerto Sof-tware Serial para recibir datos y los escribe en el Serial. La segunda placa está conec-tada al ordenador y los datos se pueden leer en el Serial Monitor. Ambas placas están conectadas de manera que el pin 0 de la primera acabe en el pin 11 de la segunda y el pin 1 de la primera esté conectado al pin 10 de la segunda. También es necesario conectar el GND entre las dos placas.El sketch para la segunda placa es el siguiente:

#include <SoftwareSerial.h>

#define SOFTRX 10#define SOFTTX 11

SoftwareSerial SerialS(SOFTRX, SOFTTX);

void setup() pinMode(SOFTTX, OUTPUT); pinMode(SOFTRX, INPUT);

delay(3000); Serial.begin(9600); Serial.write("ok");

SerialS.begin(9600);

void loop() if (SerialS.available()) Serial.write(SerialS.read());

Para utilizar SoftwareSerial es preciso importar la librería al inicio del sketch; después, el objeto se inicializa proporcionando los pines que hay que utilizar como línea de recep-ción y transmisión y, por último, se puede utilizar como una línea serial convencional.Después de haber conectado las dos placas, y de haber alimentado la primera con un alimentador exclusivo, podréis leer el recuento transmitido por la primera en el Serial Monitor conectado a la segunda (véase la Figura 10.4).

Convertidores de nivelesComo ya hemos visto, puede ocurrir que tengamos que conectar placas que trabajan a 3,3 V a otras alimentadas a 5 V. Por suerte, la mayoría de las líneas digitales trabaja en una única dirección: las salidas siempre son salidas y no se comportan alternati-vamente como entradas. Los diseñadores han inventado varias soluciones. Lo más sencillo, que funciona solo cuando se necesita pasar de 5 a 3,3 V, es utilizar un divisor de tensión (véase la Figura 10.5).

261


Si un pin de salida del microcontrolador trabaja a 5 V, el divisor dividirá la tensión para que se reduzca a 3,3 V. Se puede utilizar una resistencia de 3,3 kiloohms y una de 6,5 kiloohms. La resistencia total del divisor es de unos 10 kiloohms y la corriente vale medio miliamperio. Cuando la salida del pin está a nivel alto, en la resistencia de 6,5 kiloohms habrá 3,3 kiloohms. Cuando la salida se encuentra a nivel bajo, es decir, a 0 V, no circulará corriente y también el divisor estará a 0 V.Una solución mucho más elegante es aquella que se puede llevar a cabo con un tran-sistor MOSFET como el 2N7000. Conectándolo como en el esquema siguiente, con-seguiréis una interfaz bidireccional que puede ser conectada entre un circuito a 5 V y otro a 3,3 (véase la Figura 10.6). El circuito es obra de Herman Schutte de Philips Semiconductors Systems Laboratory Eindhoven (http://www.nxp.com/documents/application_note/an97055.pdf).Cuando la parte que trabaja a 3,3 V se encuentra en el estado alto, la VGS es igual a 0, el MOSFET se apaga y es como si no estuviera: en el lado derecho veréis 5 V mediante la resistencia R2. Si en la parte que trabaja a 3,3 V tenéis una señal baja, el MOSFET está encendido y el lado derecho ve los 0 V aplicados en el lado izquierdo.

Figura 10.4 - Conexión entre placas Arduino para la transmi-sión serie.

Figura 10.5 - Conexión de un chip con salidas a 5 V con un dispositivo a 3,3 V mediante un divisor de tensión.

262


Figura 10.6 - Interfaz bidireccional a 5 V y 3,3 V con MOSFET 2N7000.

Al aplicar una señal baja en la parte a 5 V, el MOSFET se enciende y la parte izquier-da también tendrá 0 V. Aplicando un “1”, la fuente del MOSFET y, por tanto, la parte izquierda, suben a 3,3 V y el transistor se apaga. Si hay muchas líneas que necesitan una conversión de nivel, probablemente sea mejor utilizar un circuito integrado que puede trabajar con más señales. Dos de los chips más utilizados son el 74HC245 y el 74HC4050.El 74HC4050 es propiamente un level shifter (o elevador de tensión). Puede funcionar con una tensión máxima de 7 V, pero sus entradas pueden soportar hasta 15 V y no son bidireccionales. Por tanto, podéis utilizarlo para conectar Arduino (que trabaja a 5 V) y una placa SD alimentada a 3,3 V, alimentando el chip con la misma tensión. Si a la entrada de uno de sus búfers llega una señal de 5 V, en la salida encontraréis 3,3 V.

Figura 10.7 - Esquema eléctrico de uso del 74HC4050. El chip está alimentado a 3,3 V y recibe en entrada señales de 5 V, reducidas posteriormente a 3,3 V.

263


I2CArduino está equipado también con una línea de comunicación I2C (Inter Integrated Circuit)27, un práctico sistema para el intercambio de datos que utiliza solo dos cables, además de la toma de tierra. Este protocolo fue inventado en 1982 por Philips para que varios circuitos integrados se comunicaran entre ellos. El I2C utiliza un master y uno o más slaves que comparten dos líneas denominadas:

• SDA (Serial Data);• SCL (Serial Clock).

Con dos cables es suficiente porque cada slave tiene su propia dirección y, cuando el master se quiere comunicar con un circuito periférico, en primer lugar anuncia con qué dispositivo quiere hablar, para que este se prepare para la comunicación. Así, se aho-rran las conexiones CS (oSS) que requiere, por ejemplo, el protocolo SPI. La velocidad de transmisión es normalmente de 100 kb/s, aunque es posible trabajar también a baja velocidad a 10 kb/s.En las últimas versiones de Arduino, es posible encontrar dos pines SDA y SCL situa-dos junto al pin 13; si no, los mismos pines se pueden encontrar en correspondencia con las entradas A4 (SDA) y A5 (SCL). Para que se comuniquen dos circuitos con I2C, no os tendréis que preocupar por los detalles a bajo nivel para la transmisión de los bits, pues podéis utilizar la práctica librería Wire.h, incluída en el entorno de desarro-llo. Arduino puede ser configurado como dispositivo master o slave.Para utilizar el protocolo I2C, en primer lugar debéis incluir la librería al inicio del sketch:

#include <Wire.h>

Para inicializar la interfaz, utilizáis el método begin(), que, en el caso del master, no requiere ningún argumento; para un slave, en cambio, es preciso proporcionar la di-rección asociada.

Wire.begin();

Para inicializar un slave que responda a la dirección “7”:

Wire.begin(7);

Cuando el master quiere transmitir datos, indica a qué dispositivo quiere enviarlos. Para ello, utiliza:

Wire.beginTransmission(7);

27 A veces también denominada TWI (Two Wire Interface), es decir, «interfaz de dos cables».

264


Los datos se envían mediante la instrucción write(), para enteros y secuencias de ca-racteres:

Wire.write("Wow!"); int x = 10;Wire.write(x);

La sesión de envío de datos concluye con:

Wire.endTransmission();

Para recibir datos en un slave, se utiliza un enfoque «a eventos», declarando con onRe-ceive() qué función se invocará cada vez que lleguen datos a la línea I2C.

Wire.onReceive(nombre_función);

El protocolo puede ser utilizado en dos modalidades:• el master solicita datos a los slaves;• el master envía datos a los slaves.

Intentad conectar dos placas Arduino como en la Figura 10.8. No es necesario entre-cruzar las líneas como ocurre en la comunicación de serie:

• el SDA del master se conecta al SDA del slave;• el SCK del master se conecta al SCK del slave.

Para una configuración correcta del circuito, las dos líneas deben estar conectadas cada una a una resistencia de pull up de tensión de alimentación positiva; también el GND debe colocarse en común. Para la resistencia de pull up, se pueden utilizar resistores de 1,5 kiloohms.

Figura 10.8 - Esquema de co-nexión de dos placas Arduino con la línea I2C.

265


Como es habitual, prestad atención si pensáis comunicar placas que trabajan a 3,3 V con otras que lo hacen a 5 V.Programad ambas placas y después conectad entre ellas los pines SDA, SCL, GND y 5 V, de manera que sea la placa master la que alimente a la placa slave llevando los 5 V de la primera a la segunda. Tras haber programado y conectado las dos placas, debéis conectar la placa master a vuestro ordenador y abrir el Serial Monitor para leer los mensajes recibidos. Este es el sketch para el master:

#include <Wire.h>

void setup() Wire.begin(); //setup del protocolo como master Serial.begin(9600); //setup del serial

void loop() Wire.requestFrom(7, 12); //solicita 12 bytes al dispositivo número 7

while (Wire.available()) char c = Wire.read(); Serial.print(c);

delay(500);

El sketch configura la placa como master; de hecho, la función begin() no especifica ninguna dirección. En el setup() se configura también la linea de serie para leer los datos recibidos con el Serial Monitor. En el loop() el master solicita 12 bytes al slave con la dirección “7” y es-pera la recepción con un ciclo while(). Los caracteres recibidos se envían al Serial Monitor.Este es el sketch para el slave:

#include <Wire.h>

void setup() Wire.begin(7); //setup como slave que responde a la dirección 7 Wire.onRequest(trasmettiDati);

void loop()

void transmiteDatos() Wire.write("hello world!");

En el setup del slave, se asigna la dirección “7” a la placa y después se asocia a una función que deberá llamarse en el caso en que el master solicite algún dato. La función se denomina transmiteDatos. El loop está vacío y, cuando un master solicite datos, la función transmiteDatos enviará a la línea I2C la cadena "hello world!".

266


En este primer ejemplo, es el master quien solicita datos a un slave, pero es posible configurar el sistema para que sea el master quien envíe los datos. Este es el sketch para el master que transmite a un slave una secuencia de números:

#include <Wire.h>

void setup() Wire.begin();

byte x = 0;

void loop() Wire.beginTransmission(7); Wire.write(x); Wire.endTransmission(); x++; delay(500);

El sketch para el slave sería el siguiente:

#include <Wire.h>

void setup() Wire.begin(); Wire.onReceive(recibeDatos); Serial.begin(9600);

void loop()

void recibeDatos (int n) int x = Wire.read(); Serial.println(x);

En este segundo ejemplo, el slave deberá estar conectado al ordenador y, por tanto, al Serial Monitor. El master envía un byte cada medio segundo al slave 7, que recibe el dato llamando a la función recibeDatos. El mecanismo se denomina «a eventos» por-que la función se activa solo en caso de recepción de datos.Son muchos y variados los dispositivos que podéis conectar a Arduino utilizando este protocolo, que tiene la ventaja de utilizar solo dos cables. En ocasiones, algunos dispo-sitivos proporcionan librerías que se basan en la Wire.h y simplifican posteriormente el uso del hardware que se conectará.El protocolo es más lento respecto al SPI y está indicado para la transmisión de peque-ñas cantidades de datos, sobre todo en presencia de muchos dispositivos periféricos.

267


SPILa interfaz SPI es otro protocolo muy conocido que podéis utilizar para comunicar Arduino con otros dispositivos. El SPI (Serial Peripheral Interface) es una interfaz serie síncrona, es decir, que necesita un reloj para transferir datos. En una transmisión serie asíncrona, el reloj no existe. El SPI también utiliza un transmisor master o uno o más receptores slaves. La comunicación se produce en dos direcciones, pero quien controla las operaciones es siempre y solo el master, el cual normalmente es el microcontrola-dor y activa cada uno de los slaves utilizando una línea exclusiva. La línea del reloj per-mite no tener que preocuparse de que el transmisor y el receptor trabajen a la misma frecuencia, porque es el master quien proporciona la temporización. La interfaz SPI está formada por las siguientes líneas:

• MOSI (Master Out Slave In) – utilizada para enviar datos del master al slave;• MISO (Master In Slave Out) – utilizada por el master para recibir datos desde

el slave seleccionado;• SCK (Serial Clock) – la señal de sincronización;• CS – Chip Select o SS (Slave Select), es decir, la línea para activar un slave (ha-

bitualmente, el slave se activa poniendo la línea a LOW);• GND – todos los dispositivos conectados deben compartir también la toma de

tierra (GND).

Si se dispone de más de un slave, para cada uno de ellos se utiliza una línea «indepen-diente». Esta característica podría ocupar varios pines de Arduino en el caso en que utilicéis muchos dispositivos. Existe un esquema de conexión que consigue que la línea MISO sea común para todos los slaves, que haya un único SS para todos y que todos los dispositivos estén conectados en cadena (daisy-chain). Los datos, en este caso, pasarán a través de todos los dispositivos slave. La ventaja del SPI es una mayor velocidad de comunicación y la posibilidad de transmitir datos más complejos.Realizar una simple comunicación mediante el puerto SPI no es complicado con Ar-duino gracias a la librería SPI.h, que debéis recordar de incluir al inicio del sketch:

#include <SPI.h>

Tras haber inicializado el puerto con:

SPI.begin();

es preciso activar el slave llevando a LOW la línea CS. Después, ya es posible transmitir bytes con:

SPI.transfer(byte b);

268


Al finalizar la transmisión, esta debe cerrarse con:

SPI.end();

Es posible modificar algunos de los parámetros de una transmisión SPI para variar los tiempos y la forma de las señales generadas. Las configuraciones se especifican como parámetros del método SPI.beginTransaction(). Para más información, podéis consul-tar la página de referencia de la librería (https://www.arduino.cc/en/Reference/SPI).Las líneas SPI de Arduino son accesibles, tal y como se describe en la Tabla 10.2.

Tabla 10.2 - Posición de las líneas SPI en algunas placas Arduino.

Arduino Uno Arduino Mega

SCK 13 52MISO 12 50MOSI 11 51

SS 10 53

La SPI También está conectada a un header «exclusivo», utilizado normalmente con un programador externo.

Figura 10.9 - Header ICSP con los pines SPI.

El puerto SPI se utiliza para conectar múltiples periféricos a Arduino, como tarjetas de red, sensores, chips de memoria y tarjetas SD.

269


Para terminar, aquí os dejo algunos vínculos para saber más sobre esta interfaz:• https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi;• https://www.arduino.cc/en/Reference/SPI.

RS232 & Co.Muchos sensores y dispositivos complejos disponen de un puerto serie de tipo RS23228 o RS485. Tiempo atrás, casi todos los ordenadores contaban con un puerto de este tipo, que actualmente es toda una rareza. Es posible añadirlo al ordenador uti-lizando un cable USB dotado de un convertidor USB/RS232. El RS232 nace sobre 1960 y utiliza un sistema de transmisión muy similar al del puerto serie de Arduino; además, proporciona líneas adicionales para el control de flujo y de errores de transmisión. No es posible conectar directamente los pines TX y RX a un puerto de este tipo porque no trabajan a 5 V (normalmente utilizan tensiones de 9 o 12 V). Este tipo de líneas de serie son asíncronas y no utilizan una señal de sincronización (reloj). El transmisor y el receptor deben acordar previamente la velocidad de transmisión (indicada en bau-dios).Los puertos serie RS485 son similares a los RS232, pero utilizan un sistema distinto para la transmisión de señales que hace posible el uso de líneas más largas.Habitual-mente se utilizan en entornos industriales, donde las distancias son mayores y las interferencias presentes pueden influir en el buen fin de las transmisiones de datos.Para conectar sin problemas Arduino a una línea RS232 o RS485, es necesario utilizar un chip especial para la adaptación de niveles (MAXIM MAX3323) o bien, para los más perezosos, una shield lista para usar.

BluetoothEs posible ampliar el concepto de puerto serie utilizando una tarjeta Bluetooth29 y eliminado los cables de conexión. Con un par de tarjetas breakout Bluetooth podéis realizar una conexión serie sin cables entre Arduino y un sensor, un ordenador u otro Arduino. Existen múltiples tarjetas Bluetooth, algunas dotadas de dos simples líneas TX y RX que pueden ser conectadas directamente a los pines TX y RX de Arduino (en-trecruzando las conexiones: TX en RX y viceversa). Algunas tarjetas tienen más pines para comprobar si se ha establecido la conexión o para cambiar los parámetros de la

28 El nombre completo sería EIA RS232, que significa Electronic Industries Alliance Recommended Standard 232. Estas siglas nacen en los EEUU; en Europa, podemos encontrar este puerto serie con el nombre de CCITT V21/V24.

29 El nombre «Bluetooth» está inspirado en un rey danés, Harold Bluetooth, que reinó sobre el año 1000 d.C. y consiguió poner de acuerdo los pueblos escandinavos introduciendo el cristianismo. El logo combina las runas correspondientes a la B y la H, las iniciales de su nombre.

270


tarjeta dinámicamente. Algunas tarjetas trabajan a 3,3 V y pueden ser utilizadas solo con adaptadores de nivel adecuados (como los que hemos descrito en este capítulo).Los dispositivos Bluetooth tienen un alcance limitado que, aun así, puede llegar a los cien metros, utilizando antenas o potencias más elevadas (clase I). Los dispositivos comunes alcanzan unos metros de distancia (clase II y III). Otros transceptores Blue-tooth se conectan para formar una red que se denomina piconet. En una red piconet siempre hay un único dispositivo master y uno o más slaves. El master puede comu-nicarse con cualquier slave, mientras que los slaves pueden comunicarse solo con su master e indirectamente con otro slave. Todas las tarjetas tienen asociada una direc-ción única, denominada mac address, formada por 12 caracteres hexadecimales.La última versión del Bluetooth es la 5 y los nuevos dispositivos tienen la posibilidad de funcionar consumiendo muy poca energía. En estos casos, se habla de Bluetooth low energy (BLE) y es posible alimentar los circuitos con pequeñas baterías que pue-den durar incluso meses. Los dispositivos BLE no son compatibles con los «clásicos», mientras que un Bluetooth 5 sí es compatible con las versiones anteriores en cuanto a las funciones básicas, como la transmisión de datos y de audio. Estos dispositivos de bajo consumo energético son muy apreciados para aplicaciones wearable, es de-cir, «portables», creadas mediante la combinación de componentes electrónicos con tejidos clásicos o especiales (por ejemplo, tejidos que reaccionan a la corriente o se comportan como sensores).Existen múltiples tarjetas Bluetooth que podéis conectar a Arduino. Las soluciones más sencillas están alimentadas a 5 V y utilizan solo dos líneas para transmitir y reci-bir datos. Algunos de estos módulos se denominan tarjetas Bluetooth HC03, HC05, HC07 y valen menos de diez euros. Las siglas indican solo el tipo de firmware cargado en los módulos, que normalmente utilizan un chip denominado CSR BC417 (o similar). Las tarjetas HC05 pueden funcionar como master y también como slave. El Bluetooth que contiene vuestro teléfono u ordenador es probablemente del tipo master (porque es posible conectarle un teclado, un ratón, auriculares, etc.) y, por tanto, se puede utilizar para comunicarse con una HC03. Otra tarjeta muy conocida es la Bluetooth Mate Silver de SparkFun, que puede utilizarse como un cable serie y se conecta direc-tamente a un Arduino Pro o a una Lilypad.Todas las tarjetas pueden ser programadas mediante el envío de comandos textuales especiales, denominados comandos AT, con los cuales es posible configurar el nom-bre asociado a la tarjeta Bluetooth, la velocidad de comunicación, el código de identi-ficación, entre otros parámetros.Desgraciadamente, cada tarjeta tiene sus particularidades y, a menudo, requiere co-mandos y modalidades de programación específicas: en alguna ocasión, tendréis que

271


consultar la hoja de especificaciones técnicas y el material informativo proporcionado por el fabricante.

Antes de conectar un módulo Bluetooth a Arduino, comprobad la tensión de trabajo del módulo: algunos funcionan a 5 V y otros, a 3.

Ahora os quiero presentar un pequeño prototipo para controlar un LED utilizando una tarjeta Bluetooth. Necesitáis una placa Arduino y un módulo Bluetooth. Para controlar el circuito a distancia, es posible utilizar un teléfono o un ordenador con Bluetooth. En primer lugar, debéis configurar la tarjeta Bluetooth. Para este ejemplo, he utilizado un módulo DFRobots Bluetooth 2.0 Module V3. Para programar el módulo, se necesita un terminal para enviar los comandos AT. Debéis utilizar el puerto serie de Arduino para conseguir que el ordenador hable con el módulo Bluetooth. Conectad el módulo a Arduino, como se muestra en la Figura 10.10.

Figura 10.10 - Conexión de Arduino con el módulo Bluetooth.

El módulo está conectado a los pines 6 y 7, en los cuales se encuentra configurada una Software Serial. El sketch es el siguiente:


SoftwareSerial SSerial(6, 7); // RX, TX

void setup() Serial.begin(38400); while (!Serial)

272


Serial.println("OK"); SSerial.begin(38400);

void loop() if (sSerial.available()) Serial.write(sSerial.read()); if (Serial.available()) sSerial.write(Serial.read());

El módulo Bluetooth está alimentado por Arduino. La línea TX del Bluetooth está co-nectada al pin 6 y la línea RX del Bluetooth, al pin 7. Tras haber cargado el sketch, debéis configurar correctamente la velocidad del Serial Monitor. Con el módulo DFRo-bots se debe ajustar un pequeño switch de la placa para habilitar la programación y, a continuación, configurar la velocidad de transmisión a 38.400 baudios añadiendo los caracteres CR+LF en el Serial Monitor de Arduino.Si las conexiones son correctas, al teclear el comando AT, el módulo debería responder con un OK. El módulo DF necesita una serie de comandos para modificar el nombre asignado a la tarjeta, el pin de seguridad, la velocidad de trabajo. Este es un ejemplo de secuencia de comandos con su correspondiente respuesta:

ATOKATOKAT+NAME+NAME:dfrobotv3OKAT+role+ROLE:0OKAT+PSWD+PSWD:1234OKAT+UART+UART:9600,0,0OKAT+name=zmakerbtOKat+name+NAME:zmakerbtOKat+resetOK

273


Tras haber configurado el módulo y haber desactivado la modalidad «programación» con el correspondiente switch, podéis cargar el sketch para encender el LED enviando caracteres por Bluetooth.


SoftwareSerial SSerial(6, 7); // RX, TX

void setup() Serial.begin(9600); while (!Serial) Serial.println("OK");

SSerial.begin(9600);

pinMode(13, OUTPUT);

void loop() if (SSerial.available()) char ch = SSerial.read(); if (ch == 'a') digitalWrite(13, HIGH); if (ch == 's') digitalWrite(13, LOW); Serial.write(ch);

El sketch es muy sencillo: cuando el Software Serial recibe el carácter a desde el módu-lo Bluetooth, enciende el LED en el pin 13. Para apagar el LED, debéis enviar el carácter s.¿Cómo se envían estos caracteres? Podéis utilizar un smartphone con una app tipo Bluetooth Terminal, que es parecida al Serial Monitor de Arduino. Una vez encendi-do Arduino con el módulo Bluetooth conectado, deberíais ver el módulo con la app. Conectaos introduciendo el PIN (si no lo habéis cambiado será el predeterminado: normalmente es 1234, 0000, 1111 o similar). Una vez establecida la conexión, probad a escribir una “a” y una “s” para controlar el LED (véase la Figura 10.11). Si se utiliza un módulo Bluetooth de baja energía (BLE) o Bluetooth 4.0, no existen a penas diferencias respecto a cuanto acabamos de ver. Esta tecnología presenta la ven-taja de poder ser utilizada sin dificultades con teléfonos Apple, los cuales siempre han tenido grandes limitaciones en el uso del Bluetooth clásico. Para teléfonos Android, se necesita un hardware que pueda comunicarse con el Bluetooth 4.0 y una versión del sistema operativo superior o igual a la 4.3.Para más información acerca del Bluetooth:

• https://learn.sparkfun.com/tutorials/bluetooth-basics/what-is-bluetooth;• http://forum.arduino.cc/index.php?topic=104903.0.

274


Figura 10.11 - Conexión al Bluetooth con la app Bluetooth Terminal y envío de caracteres a Arduino.

ZigBeeOtro estándar de comunicación por radio de bajo consumo energético es ZigBee (http://www.zigbee.org). Los dispositivos ZigBee son pequeños transceptores que pueden crear redes extendidas formadas por varios nodos y dispositivos periféricos. Estos dispositivos nacieron para ser utilizados en aplicaciones domóticas e industria-les, consumir poca energía y costar muy poco. De hecho, aunque el coste estimado de un transceptor es de pocos dólares, a la práctica las radios pequeñas suelen costar unos veinte euros. Un módulo ZigBee puede ser conectado a Arduino mediante un puerto serie o bien con una shield especial. Los ZigBee también se pueden montar sobre pequeños «zócalos» que se conectan a un ordenador mediante un cable USB.

EthernetEl método más conocido para conectar entre sí dos o más ordenadores es mediante una red Ethernet. Cada ordenador está dotado de una tarjeta de red que tiene asocia-da una dirección física única denominada mac (del tipo AB:02:3C:23:B0:FF). Además de esta dirección, se puede asociar una dirección IP formada por cuatro números com-

275


prendidos entre el 0 y el 255, separados por un punto (por ejemplo, 192.168.0.1). Nor-malmente, en las redes se utiliza esta última dirección para conseguir la comunicación entre los ordenadores. La dirección sirve para hacer llegar el mensaje (los datos) al destinatario correcto y para que este destinatario sepa quién se los ha enviado. Las conexiones se realizan todas por cable, aunque actualmente se tiende a eliminar los cables a favor de las redes wireless.Arduino Ethernet cuenta con una tarjeta de red integrada directamente en el lugar del puerto USB. También existe una tarjeta especial de expansión denominada Ethernet Shield que se puede añadir a Arduino Uno. Hoy en día, estas soluciones «cableadas» es-tán cayendo poco a poco en desuso a favor de las conexiones sin cables, aunque un ca-ble Ethernet es muy fiable y puede garantizar altas velocidades de transmisión. La placa Ethernet de Arduino utiliza un chip WIZnet que realiza la comunicación mediante el pro-tocolo SPI, utilizando los pines 10, 11, 12 y 13. Tanto Arduino Ethernet como la Ethernet Shield tienen una ranura para tarjeta de memoria SD, a menudo utilizada para «trabajar con» archivos HTML «servidos» por Arduino, ¡que puede funcionar como servidor web!El cableado en estos casos es muy sencillo, a menos que tratéis de construir vosotros mismos la tarjeta de red utilizando el chip WIZnet. La forma más sencilla de hacerlo es conectando Arduino a una red Ethernet, asignarle una dirección IP e intentar leer una página web.En vuestra placa encontraréis un pequeño adhesivo que muestra la dirección mac de la tarjeta. La dirección se asemeja a 90-A2-DA-00-00-00, en la cual los tres primeros números (90, A2 y DA) identifican el productor y los otros tres son una serie asignada a cada tarjeta producida. La dirección mac siempre debe aparecer en el sketch. En teo-ría, si no conectárais vuestro Arduino directamente a Internet, no habría ningún proble-ma con la dirección mac; sin embargo, se considera una buena praxis copiar la correcta.Antes de conectar la placa Arduino en red, deberéis asignarle también una dirección IP30. En vuestra red doméstica tenéis un router o un módem con una dirección asociada del tipo 192.168.0.1; cualquier otro ordenador, teléfono o dispositivo conectado a la red tiene una dirección similar, que sirve para hacerle entender correctamente las infor-maciones, como ocurre con las direcciones postales. En vuestra red, podréis tener, por ejemplo:

• 192.168.0.2 asignado a vuestro ordenador;• 192.168.0.4 asignado a vuestro teléfono.

Arduino también deberá tener una dirección válida. Si os conectáis al router, podéis controlar qué direcciones están libres y cuáles están ocupadas.

30 La siguiente es una explicación for dummies de cómo funciona una red IP.

276


La dirección IP está formada por cuatro campos en los cuales podéis indicar un nú-mero que va del 0 al 255. Cada ordenador conectado a Internet tiene una dirección IP única. Las redes «domésticas» no están conectadas directamente a Internet, sino mediante vuestro módem y un proveedor. La red que crea el router es, de alguna ma-nera, independiente de la red global y se distingue también por el tipo de dirección que utiliza (todas empiezan por 192.168.x.x).Al inicio de un sketch, para conectar a Arduino en red, encontraréis los parámetros que se deben asignar a vuestra placa. Además de la dirección IP, también está el ga-teway, que, explicado en dos palabras, es la «línea» que se utiliza para salir hacia In-ternet. Como sabréis, existen direcciones IP que se utilizan localmente y otras, que son «públicas»: la subnet, o subnet mask, sirve para distinguir de qué tipo de dirección estamos hablando y, por tanto, para enviar correctamente los datos a una dirección local o a Internet, a través del gateway (¡esta es una explicación muy simplificada!).Al inicio de cada sketch para Arduino Ethernet o para la Ethernet Shield, tendréis que incluir las librerías SPI y Ethernet:

#include <SPI.h>#include <Ethernet.h>

En el setup debéis insertar las configuraciones de red:

byte mac[] = 0x90, 0xA2, 0xDA, 0x0E, 0xD5, 0xB1; byte ip[] = 192, 168, 0, 41 ; byte gateway[] = 192, 168, 0, 1 ; byte subnet[] = 255, 255, 255, 0 ;

A continuación, debéis activar la conexión con:

Ethernet.begin(mac, ip, gateway, subnet);

También se puede conectar Arduino a la red Ethernet sin asignar una dirección IP. Existe un sistema denominado DHCP que asigna automáticamente una dirección a vuestra tarjeta. Este sistema necesita normalmente más tiempo y puede producir errores. Para intentar una conexión «dinámica», es preciso una única dirección mac:

if (Ethernet.begin(mac) == 0) Serial.println("Obtención IP dinámico: ¡ha fallado!");

Una vez conectada la placa, podemos escribir código más o menos complejo para que se comporte como un servidor web o que lea páginas o contenidos de Internet. Estas acciones requieren la escritura de cierta cantidad de código, no siempre sencillo. Lo mejor es empezar por los ejemplos proporcionados con Arduino en el menú Exam-ples > Ethernet. Abrid el sketch para leer una página web (denominado WebClient),

277


del cual muestro a continuación una versión comentada. No os olvidéis de copiar la dirección mac de la placa antes de cargar el sketch.

#include <SPI.h>#include <Ethernet.h>

byte mac[] = 0x90, 0xA2, 0xDA, 0x0E, 0xD5, 0xB1 ;char server[] = "www.google.com";

EthernetClient client;


Ethernet.begin(mac);

delay(1000); Serial.println("conexión…"); if (client.connect(server, 80)) Serial.println("conectado"); // Make a HTTP request: client.println("GET /search?q=arduino HTTP/1.1"); client.println("Host: www.google.com"); client.println("Connection: close"); client.println(); else Serial.println("error de conexión");

// if there are incoming bytes available // from the server, read them and print them: if (client.available()) char c = client.read(); Serial.print(c);

// if the server's disconnected, stop the client: if (!client.connected()) Serial.println(); Serial.println("disconnecting."); client.stop();

void loop()

La dirección que leerá Arduino es la de la página de inicio de Google. Para leer los da-tos de la página web, se utiliza EthernetClient, que devuelve un flujo de caracteres. Uti-lizando la Ethernet Shield se debe descender a bajo nivel: es preciso escribir también las solicitudes explícitas para el servidor (con Arduino Yún, explicado en el próximo capítulo, las cosas son mucho más sencillas).EthernetClient se conecta al servidor de Google indicando también el puerto. Cada dirección IP puede tener asociado más de un servicio: correo electrónico, ping, http,

278


telnet, etc. Cada servicio responde a un único puerto. Las páginas web normalmente son «servidas» por un servidor que responde al puerto 80. Por tanto, EthernetClient se conectará al puerto 80 y podrá enviar y recibir datos con el servidor web. Para solicitar una página, es preciso enviar una secuencia de cadenas mediante client.println(). El cliente esperará la respuesta del servidor con los datos de la página HTML y los leerá, carácter a carácter, mostrándolos en el Serial Monitor.

Figura 10.12 - Detalles de la conexión web mostrados en el Serial Monitor.

Arduino también puede comportarse como un servidor web, publicando una página que puede ser consultada con el navegador de un ordenador conectado a la misma red. Veamos un ejemplo para publicar una página HTML desde la cual controlar el encendido de un LED. Con la Ethernet Shield, tendremos que dejar libre el pin 13 y uti-

279


lizar el pin 9. En Arduino Ethernet, el LED «de servicio» está directamente conectado al pin número 9.En este ejemplo, asignaremos una dirección IP fija a la placa para que no tengamos problemas para encontrar la página con el navegador. El sketch es el siguiente:

#include <SPI.h> #include <Ethernet.h> byte mac[] = 0x90, 0xA2, 0xDA, 0x0E, 0xD5, 0xB1; byte ip[] = 192, 168, 0, 41 ; // dirección IP de la shield byte gateway[] = 192, 168, 0, 1 ; // dirección ip del router byte subnet[] = 255, 255, 255, 0 ; //subnet mask

EthernetServer server(80);

int led = 9;String readString;

void setup() Ethernet.begin(mac, ip, gateway, subnet); pinMode(led, OUTPUT); Serial.begin(9600);

void loop() EthernetClient client = server.available(); if (client) boolean currentLineIsBlank = true; while (client.connected()) if (client.available()) char c = client.read(); readString.concat(c);

if (c == '\n' && currentLineIsBlank) Serial.print(readString); if (readString.indexOf("led=1") > 0) digitalWrite(led, HIGH); else digitalWrite(led, LOW);

client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.print("<html><body><h1>WebLed</h1>"); client.print("<a href='/?led=1'>ON</a> | <a href='/?led=0'>OFF</a>"); client.println("</body></html>"); readString=""; client.stop();

280


En el setup del sketch se crea la conexión de red y se inicializa el puerto serie. Antes del setup se crea un objeto EthernetServer denominado server que responderá al puerto 80, como lo haría un servidor web. En el loop(), server.available() espera una solici-tud para el servidor. En cuanto se conecta un cliente (por ejemplo, cuando se abre el navegador y se escribe la dirección 192.168.0.41), el servidor libera un cliente Ethernet que gestiona la solicitud. El cliente recibe la solicitud que procede del navegador y de esta consigue también la dirección deseada. Si en la dirección se muestra la secuencia led=1, se activa la salida digital a la cual se encuentra conectado el LED; si no, la línea permanece a bajo nivel. El cliente pasa a continuación a «servir» la página web al navegador. En la página hay dos vínculos, uno para encender el LED y otro para apagarlo. Para pro-barlo todo, compilad el sketch y cargadlo en un Arduino conectado en red. Comprobad que la dirección IP sea correcta también para vuestra red; para ello, abrís un navegador y accedéis a la dirección 192.168.0.41 (véase la Figura 10.13).

Figura 10.13 - La página web servida por Arduino.

Cómo hacer que Arduino sea visible en Internet

Arduino está conectado al router de vuestra red doméstica: no está en Internet. Sin embargo, es posible «hacer que salga» para poder verlo también fuera de vuestra red. La operación se denomina router port mapping y no siempre es posible realizarla. Tenéis que conectaros a vuestro router e identificar la conexión de Ar-duino: la reconoceréis por la dirección IP y la dirección mac. Según el router, veréis la sección Port Mapping, en la cual se debe crear una «regla» donde declarar que el tráfico procedente del puerto 80 de vuestro Arduino se podrá ver fuera de dicho puerto o de otro que deseéis.

281


No todos los proveedores permiten este tipo de operación y, si no funciona, ten-dréis que encontrar un sistema alternativo, como recurrir a un servidor externo para publicar los datos procedentes de vuestro Arduino o dirigidos a él.Podéis escribir de forma independiente el servidor público con el cual se comuni-cará Arduino (por ejemplo, en PHP), utilizando un hosting externo, o bien con un proveedor IoT, como Paraimpu (https://www.paraimpu.com/) para conectar en red vuestros dispositivos de manera sencilla y muy elegante.

WiFi En el mundo actual los cables están desapareciendo. Son habituales los entornos con redes wireless. En pocas palabras, una red wireless WIFI funciona como Ethernet, pero sin molestias de cables. La tecnología ha evolucionado hasta tal punto que este tipo de conexión ya se puede comparar con la conexión por cable, aunque siempre puedan surgir problemas. Por lo general, una conexión sin cables es menos fiable que una por cable, puesto que el entorno influye en la propagación de las ondas de radio y puede verse afectado por numerosas interferencias. Una comunicación por radio WiFi impli-ca la presencia de otros dispositivos que intentan comunicarse en el mismo intervalo de frecuencias y que, por tanto, crean tantas interferencias como transceptores exis-ten: como cuando se intenta hablar en una sala llena de gente.Las transmisiones WiFi requieren cierta potencia y, para una buena fiabilidad en la transmisión de datos, necesitan baterías de cierta capacidad que limitan la autonomía de un dispositivo portátil.Podéis eliminar el cable de red de vuestros proyectos añadiendo una tarjeta WiFi. Te-néis varias posibilidades, entre las cuales la WiFi Shield oficial de Arduino y distintas placas breakout, como la CC3000 de SparkFun. Las tarjetas WiFi tienen normalmente un coste bastante elevado respecto a otras soluciones como el Bluetooth. La WiFi Shield oficial cuesta unos 75 euros, mientras que otras tarjetas similares y compati-bles valen unos diez euros. Estas tarjetas se comunican con Arduino utilizando la in-terfaz SPI, por lo que la conexión eléctrica y el funcionamiento son bastante similares a los de la tarjeta Ethernet.Existe una tarjeta WiFi de bajo coste (menos de diez euros), denominada ESP8266, que, en realidad, es algo más que una simple WiFi: utiliza un chip de tipo SoC (System On Chip), es decir, un pequeño microcontrolador que cuenta con todo, incluso con un WiFi integrado. La ESP8266 y Arduino se comunican por serie y, habitualmente, el control y la configuración de la tarjeta se realizan con comandos AT similares a los del Bluetooth. Los comandos pueden variar según la versión del firmware cargado, por lo que siempre es mejor consultar los manuales proporcionados por el productor de las tarjetas.

282


Figura 10.14 - Módulo WiFi CC3000 de SparkFun.

Para utilizar la WiFi, además de configurar la dirección IP como ocurre con las redes Ethernet, tendréis que insertar el nombre de la red a la cual conectar la placa y la con-traseña. Para la WiFi Shield de Arduino, existen librerías específicas que se importan al inicio del sketch. Podéis encontrar ejemplos completos en el IDE de Arduino. La librería puede conectarse a redes con protección WEP y WPA2 Personal y las instruc-ciones que se utilizan son muy parecidas a las que se utilizan para Arduino Ethernet o para la Ethernet Shield. Debido a su elevado precio, este tipo de tarjetas están ce-diendo su sitio a soluciones más económicas (como la ESP8266) o integradas (como Arduino Yún y Tian).El uso de la ESP8266 es mucho más sencillo que el de las tarjetas que utilizan una comunicación SPI, porque utilizan solo dos líneas para la transmisión en serie y, una vez configurada la tarjeta para la conexión en red, es posible transmitir y recibir los caracteres leyendo desde el puerto.Con comandos AT es posible configurar la modalidad de funcionamiento (por ejemplo, client o access point), ejecutar un análisis de las redes «visibles» o conectarse a una red.Antes de conectar un módulo ESP8266, comprobad siempre el tipo de alimentación necesaria: algunas tarjetas trabajan a 3,3 V y tendréis que utilizar adaptadores de nivel para no dañar la tarjeta WiFi con los señales de 5 V procedentes de Arduino.

GSM/GPRSAlgunos proyectos deben ser instalados en zonas en las cuales no exista ninguna co-nexión de red o WiFi. Para transmitir y recibir datos, es posible utilizar un módulo GSM, siempre y cuando la zona no sea inaccesible ni esté tan aislada que no se pueda alcanzar ni desde una red móvil. El GSM (Sistema Global de comunicación Móvil) es el sistema de telefonía móvil más extendido en el mundo y lo utilizan miles de millones de personas con una cobertura muy amplia. Igual que para la WiFi, los módulos GSM para Arduino tienen costes generalmente elevados y consumen mucha energía, ade-

283


más de necesitar una SIM y, por tanto, la apertura de un contrato con una compañía telefónica (que tienden a vender SIM con tráfico en bonos, más que por consumo). El sistema GSM es el que adoptan nuestros teléfonos móviles y proporciona distintos servicios, como la telefonía, los SMS, la transmisión de datos a través de un módem y la conexión a Internet.La GSM Shield de Arduino puede realizar y recibir llamadas, SMS y conectarse a Inter-net con el GPRS Client. Las comunicaciones con la tarjeta se llevan a cabo mediante comandos AT y con la GSMLibrary. Además de la shield oficial, existen otros módulos creados por distintos fabricantes. El coste de este tipo de tarjetas es, por lo general, bastante elevado (entre 50 y 100 euros).A modo de ejemplo, os muestro el sketch para enviar un SMS con Arduino. El código lo he conseguido del ejemplo que existe en el IDE. Para probarlo, tenéis que conectar una GSM Shield a Arduino Uno e insertar en ella una SIM activa.

#include <GSM.h>

GSM gsmAccess;GSM_SMS sms;


Serial.println("SMS Messages Sender");

boolean notConnected = true;

// setup della GSM shield while (notConnected) if (gsmAccess.begin("1234") == GSM_READY) notConnected = false; else Serial.println("Error de conexión"); delay(1000);

Serial.println("GSM pronto!"); char remoteNum[20] = "393340000000"; char txtMsg[200] = "Hello world!"; sms.beginSMS(remoteNum); sms.print(txtMsg); sms.endSMS();

void loop()

284


El sketch es muy sencillo. Como siempre, es preciso incluir la librería de gestión del hardware, que en este caso es GSM.h. El dispositivo GSM se controla con el objeto GSM, que aquí se ha denominado gsmAccess. Para el envío de los SMS, se utiliza el ob-jeto GSM_SMS. La tarjeta se configura con el método begin() de GSM. Si la SIM necesita un PIN, tendréis que proporcionarlo como parámetro en el método begin() (insertadlo como texto y no como número). El sketch inicia el setup hasta que se produce la cone-xión a la red. Cuando todo está preparado, podéis enviar un mensaje SMS indicando el destinatario con sms.beginSMS y escribiendo el texto con sms.print(). El envío se lleva a cabo con la llamada de sms.endSMS(). Os aconsejo que curioseéis entre los otros ejem-plos proporcionados con la librería.Otras tarjetas hardware podrían utilizar librerías distintas, normalmente proporcio-nadas por el fabricante.

Siguiente pasoEn este capítulo hemos echado un rápido vistazo a una serie de posibilidades para que vuestros proyectos puedan comunicarse con el mundo exterior. Las posibilidades son muchas, aunque normalmente los métodos para hacer que una tarjeta externa o una shield «hablen» con Arduino utilizan siempre los procedimientos que acabamos de describir.Además de los sistemas de transmisión y comunicación mostrados en este capítulo, existen muchos otros que podéis explorar y probar con tranquilidad. Algunos ejem-plos son:

• módulos de radio a baja frecuencia;• DMX (sistema para el control de luces, utilizado en teatros y conciertos);• MiDi (para el control de instrumentos musicales);• transmisiones opticas (IR, fibra óptica, LiFi);• sonar, radar, lidar, etc.

285

El último capítulo está dedicado a Arduino Yún, una placa

innovadora que une Arduino con un sistema Linux. La Yún

tiene una tarjeta WiFi incorporada y resulta fácil conectarla

en red para utilizar servicios web o recursos online. Con

Yún es posible realizar proyectos para el Internet de las Cosas de forma muy sencilla.

Arduino más LinuxArduino Yún31 es una placa que en su forma se asemeja por completo a Arduino Uno. Al mirarla más de cerca, podemos percibir las principales diferencias:en lugar del bloque para la conexión del cable USB hay una toma de red Ethernet;el puerto USB para la programación es un micro-USB;tiene un conector colocado en vertical para conectar otros dispositivos externos;una parte del circuito está cubierta por una placa de metal.La zona protegida por la placa metálica contiene un procesador Atheros AR9331 sobre el cual se ejecuta un sistema Linux con OpenWrt. La placa también cuenta con un microcontrolador Atmel ATmega32u4 que se comunica con el Atheros.Yún dispone de un módulo WiFi que puede conectarse a una red existente. Cuando la placa está conectada y configurada, puede ser programada tanto por USB como por WiFi. Para la programación por USB se necesita un cable micro-USB (tipo B), como el que se utiliza hoy en día para cargar tabletas y móviles. Yún une Arduino y un peque-

31 En chino, Yún significa «nube».

Arduino Yún

11

286


ño ordenador con sistema operativo Linux. Esta solución os permite crear fácilmente proyectos que utilizan Internet.Con Arduino Yún resulta muy sencillo crear proyectos que pueden conectarse fácil-mente a Internet, publicar servicios de datos, leer informaciones e interactuar con otras placas y personas. En estos casos, se habla del Internet de las Cosas (o IoT), es decir, de creaciones en las cuales el acceso y el uso de la Red se extienden a objetos y lugares. Cada vez más nos veremos empujados a trabajar con dispositivos progresiva-mente más pequeños y conectados en red. El intercambio de datos a través de Internet cada vez se utiliza más y, en un futuro, se prevé que miles de millones de dispositivos estén contectados. La cantidad de datos proporcionados por sistemas «automáticos», generados por sensores, será cada vez mayor. Actualmente ya se habla de IoT, pero es una tecnología que llegará a nuestro mundo dentro de una década, porque es preciso adaptar protocolos de red y de comunicación que ahora todavía no son adecuados para gestionar un número tan grande de objetos «twiteantes». Las aplicaciones más prometedoras del Internet de las Cosas se concentrarán en el campo de la domótica, de las ciudades inteligentes, además de en la automoción y el wearable.Aunque las auténticas tecnologías para IoT todavían están por llegar, para crear un proyecto de este tipo, Arduino Yún es actualmente una de las mejores soluciones y de las más accesibles. El equipo de Arduino ha añadido librerías para facilitar las comu-nicaciones con internet, a través de las cuales se pueden realizar fácilmente proyectos incluso muy complejos.La comunicación entre los dos chips se lleva a cabo utilizando el Bridge, una librería que simplifica su cooperación. Incluido en un sketch, el Bridge «esconde» muchas de las complejidades necesarias para conseguir que el sistema Linux hable mediante simples instrucciones en C, ejecutadas dentro de un microcontrolador. Todas las tarje-tas de red (WiFi y Ethernet), el puerto USB y la tarjeta SD se conectan al chip Atheros y, por tanto, están controladas directamente por Linux. El Bridge permite utilizar estos dispositivos en el entorno de Arduino, además de usar y generar servicios web.

InstalaciónSi ya habéis instalado una versión actualizada del IDE para Arduino, es probable que no tengáis que hacer nada para utilizar Arduino Yún; de no ser así, extraedlo de la caja y conectadlo a vuestro ordenador con un cable USB.En Windows, después de haber descargado el paquete de instalación y de haberlo ejecutado, prestad atención a las instrucciones indicadas por el software. Si habéis elegido instalar también los drivers USB, aparecerá la ventana Windows Security para confirmar la instalación y en la cual se os solicita si deseáis ampliar esta última al hardware producido por Arduino LLC: pulsad el botón Install.

287

Arduino Yún Capítulo 11

En Mac, se abrirá la aplicación Keyboard Setup Assistant, que os avisa de que se ha conectado un nuevo dispositivo USB, como si la Yún fuera reconocida como un tecla-do. Solo tenéis que cerrar la ventana con un clic en el botón rojo de la barra de título.En Linux no es necesario ninguna acción especial. En ciertos casos, es preciso ejecutar el programa con sudo.Una vez que la placa está conectada y alimentada, veréis una luz de color verde y, seguidamente, se encenderá también una luz blanca (USB). Esperad unos segun-dos a que la WiFi salga y después localizad una red WiFi denominada “Arduino Yun-xxxxxxx” (las x son números). Conectad vuestro ordenador a esta red, abrid un na-vegador (Firefox, Chrome o Internet Explorer), escribid la dirección “arduino.local” y cargad la página web de configuración de Arduino Yún. Si con la dirección “arduino.local” la página no se carga, probad a utilizar directamente la dirección IP predefinida en la placa: 192.168.240.1.

Figura 11.1 - La página web de configuración de Arduino Yún.

La contraseña predeterminada es arduino. Escribidla para acceder a la página de con-figuración en la cual encontrareís la dirección asignada a la tarjeta WiFi y de red (ETH) contenidas en la Yún. En esta página podréis encontrar también las direcciones mac del hardware. Pulsad el botón Configure situado en la parte superior derecha para confi-gurar la placa. En la configuración básica, debéis asignar un nombre a la placa e indicar

288


a qué red WiFi deberá conectarse. Proporcionad una nueva contraseña, la cual debe contener al menos ocho caracteres.Al final de la página, debajo del botón Configure & Restart, hay un pequeño panel en el cual podéis configurar el acceso open, es decir, sin contraseña. La contraseña es ne-cesaria si la placa está conectada directamente a Internet. Los REST API son servicios web publicados por vuestra placa; tenéis la posibilidad de interrogarla o de modificar su estado directamente desde un navegador. Normalmente, los servicios REST nece-sitan distintos métodos de interrogación, denominados GET, POST, DELETE, PUT. El más sencillo es el método GET, que sirve para obtener datos del recurso interrogado; se puede llamar escribiendo la dirección del recurso en un navegador.Después de haber pulsado el botón Configure & Restart, la placa se reiniciará y, si no surge ningún problema, la Yún se conectará a vuestra red WiFi. Podéis localizarla con el nombre que le habéis asignado durante la configuración (por ejemplo, “arduino”) seguido de “local”: http://arduino.local.

Programación WiFiUna vez configurada vuestra placa Yún, podréis programarla por WiFi. No será nece-sario ningún tipo de cable y tampoco tendréis que estar cerca de la misma placa.Probad a cargar vuestro primer sketch:

• encended Arduino Yún y esperad a que se conecte a la red WiFi (podéis ali-mentarlo con un cable para móvil);

• en vuestro ordenador, iniciad Arduino IDE y cargad el sketch Blink;• comprobad que en el menú Tools > Boards aparezca la placa Arduino Yún;• aseguraos de que en Tools > Port se encuentre seleccionado el puerto de red

de Arduino Yún;• pulsad el botón Verify y después Upload para cargar el sketch en la placa;• la primera vez que ejecutéis una carga hacia vuestra placa, se solicitará la con-

traseña asignada durante la instalación (véase la Figura 11.2).

La placa dispone, además, de una conexión de red Ethernet, por lo que también se puede programar con un simple cable de red.

OpenWrt-YunJunto al microcontrolador ATmega32u4, en el chip SoC Atheros, se encuentra instala-do un sistema operativo Gnu/Linux denominado OpenWrt-Yun: un auténtico sistema en el cual se puede ejecutar un servidor o una base de datos y donde podéis escribir programas en distintos lenguajes y navegar entre carpetas y archivos.

289


Figura 11.2 - Arduino Yún requiere una contraseña la primera vez que se carga un sketch.

Un sistema operativo también permite gestionar procesos y servicios y realizar ta-reas demasiado complicadas para el ATmega32u4. Los sistemas operativos no son adecuados para desarrollar operaciones en tiempo real o para comunicarse con el hardware, razón por la cual es mejor utilizar el ATmega32u4, pero simplifican mucho la integración de los propios proyectos con Internet para enviar o recibir datos de ser-vicios, gestionar periféricos o ejecutar procesos.El chip AR9331 tiene una memoria RAM de 64 MB y 16 MB de memoria flash en la cual se encuentra precargada la distribución Linux OpenWrt-Yun. De vez en cuando salen actualizaciones que se pueden cargar copiándolas en una microSD y que sobre-escriben el contenido de la memoria flash. Para aumentar el espacio en el disco, es recomendable añadir una tarjeta microSD en la cual se memoricen los scripts o las páginas web.Cuando la placa Yún está encendida y conectada, os podéis conectar a ella con un terminal, iniciar la sesión y trabajar en un entorno Linux. Si habéis trabajado en DOS y

290


escrito comandos en una consola, no os asustéis, no deberíais tener ningún problema. En cualquier caso, los comandos que hay que saber son pocos y sencillos.Para conectaros con un terminal, debéis conocer la dirección IP o el nombre de la pla-ca. Abrid un terminal32 en vuestro ordenador y probad a «pinguear» la Yún. El ping es un comando básico que permite comprobar si un ordenador, conectado en red, está encendido y operativo. Escribid ping seguido de la dirección del ordenador o del dispo-sitivo que se desea controlar. En el ejemplo siguiente, queremos comprobar si la placa Yún de la dirección “arduino.local” está activa:

ping arduino.local

Pulsad Intro y esperad la respuesta. El comando ping envía un cierto número de paque-tes continuamente (en Windows, suelen ser tres). Este es un ejemplo de respuesta:

PING arduino.local (192.168.0.11): 56 data bytes64 bytes from 192.168.0.11: icmp_seq=0 ttl=64 time=4.826 ms64 bytes from 192.168.0.11: icmp_seq=1 ttl=64 time=4.514 ms64 bytes from 192.168.0.11: icmp_seq=2 ttl=64 time=4.572 ms

Podéis llamar a ping utilizando también la dirección IP de la placa. En mi caso, el router ha asignado a la placa Yún la dirección 192.168.0.11. Conociendo la dirección, es posi-ble «pinguearla» para ver si está encendida y conectada en red:

ping 192.168.0.11

Figura 11.3 - Uso del comando ping.

32 Todos los sistemas ofrecen la posibilidad de abrir una consola. Si utilizáis Windows, podéis uti-lizar el programa gratuito PuTTY.

291


Ahora que conocéis la dirección de la placa, podéis intentar conectaros con un termi-nal. Interrumpid ping pulsando CTRL + C (también en Mac) y escribid:

ssh [email protected]

Después de pulsar Intro, se os solicitará una contraseña. Utilizad la que habéis asig-nado a la placa durante la instalación. El comando ssh se utiliza para conectarse y trabajar en modo seguro con un ordenador remoto. Para entrar en un ordenador, se debe proporcionar el nombre de un usuario del sistema y su contraseña de acceso. En este caso, el usuario especificado se denomina root, que en los sistemas Linux es la cuenta más potente que existe (una especie de superadministrador). La dirección del servidor al cual nos debemos conectar se especifica detrás del signo @. Como siempre, podéis utilizar el nombre asignado a la placa o bien la dirección IP:


Figura 11.4 - Acceso remoto mediante ssh y mensaje de inicio de sesión de OpenWrt.

Es posible que la primera vez que os conectéis con ssh a Arduino Yún recibáis este mensaje:

The authenticity of host '192.168.0.11' can't be established. RSA key fingerprint is aa:bb:cc:03:27:22:d3:f1:68:48:58:99:ae:c3:64:6f. Are you sure you want to continue connecting (yes/no)?

292


Vuestro ordenador es sospechoso y os está preguntando si conocéis el servidor al cual os intentáis conectar. Contestad yes para añadir la dirección entre las de confianza.

Warning: Permanently added '192.168.0.11' (RSA) to the list of known hosts.

A menudo, en los sistemas GNU/Linux se trabaja utilizando un terminal o una cone-xión remota. Actualmente, la mayor parte de nosotros utilizamos sin problemas sistemas «con terminal», pero no es difícil aprender algunos comandos sencillos de supervivencia. A continuación, os facilito una breve panorámica con los comandos mínimos para empe-zar a utilizar Linux. Si queréis saber más acerca del uso de alguno de los comandos, po-déis buscarlo en Google, donde encontraréis muchísima información sobre estos temas.Linux utiliza una organización de archivos y carpetas en las cuales podéis situaros me-diante el comando cd seguido del nombre de la carpeta en la cual queréis entrar. Para «ascender» por el árbol, podéis utilizar cd seguido de dos puntos:

cd ..

Orientarse así no es sencillo y es muy fácil perder el norte. Para saber dónde os encon-tráis en cada momento, podéis utilizar el comando pwd, que mostrará vuestra posición actual. Otra posición «especial» es la root (raíz) del sistema de archivos, a la cual se puede acceder escribiendo:

cd /

Para ver «todo cuanto os rodea», utilizad ls, que mostrará una lista de archivos y car-petas visibles desde vuestra posición actual. Ejecutando ls en la raíz del sistema de archivos podréis ver una lista de carpetas estándar comunes a todos los sistemas Linux. En Arduino Yún son las siguientes:

• bin – contiene los comandos del sistema;• etc – contiene los archivos de configuración del sistema y del software instala-

do;• mnt – es la carpeta dónde están «montados» los discos externos (o la microSD);• proc – es una carpeta con un archivo para cada proceso activo;• root – es la carpeta básica del usuario root;• usr – contiene los programas instalados;• www – es una carpeta que contiene los archivos proporcionados por el servidor

web;• dev – contiene archivos especiales, vinculados a cualquier dispositivo de hard-

ware conectado al sistema;• lib – para las librerías de sistema;• sbin – con los comandos para el «súper-usuario» root;

293


• tmp – carpeta para los archivos temporales;• var – contiene los datos generados por el sistema mientras está activo (por

ejemplo, los log).

Añadiendo la opción l al comando ls podréis visualizar también informaciones adicio-nales para cada archivo, como la fecha de creación, el autor y los permisos.

ls –l

Las informaciones aportadas por ls –l son: los permisos del archivo, el número de co-nexiones al archivo, el autor, el grupo, el tamaño, la fecha de la última modificación y el nombre. El comando ls colorea los elementos mostrados, por lo que podréis ver los ar-chivos en blanco o verde (si son ejecutables), las carpetas en azul marino, los vínculos en azul celeste, los dispositivos en rosa. Los permisos para los archivos son una cadena aparentemente incomprensible: un primer carácter indica si la línea se refiere a un úni-co archivo (-) o a un directorio (d); después, aparecen tres grupos de caracteres que corresponden a los permisos de lectura (r), de escritura (w) y de ejecución (x) del archi-vo. Si no se ha asignado ningún permiso, en lugar de la letra aparacerá un guion (-). Los tres grupos se refieren al propietario, al grupo33 y a cualquier usuario. Un archivo con:

-rwxr-xr--

puede ser leído, escrito y ejecutado por su propietario (rwx), leído y ejecutado por los usuarios que pertenecen al mismo grupo que el propietario (r-x) y solo leído por el resto de usuarios (r--). El carácter x para los directorios corresponde a la posibilidad de entrar en la carpeta.Para cambiar los permisos de un archivo, se utiliza el comando chmod seguido de al-gunas opciones y del nombre del archivo que hay que procesar. Para hacer que un archivo sea ejecutable se puede utilizar:

chmod +x nombrearchivo

Para eliminar el permiso de ejecución:

chmod –x nombrearchivo

Para modificar el propietario del archivo, existe el comando chown, mientras que chgrp modifica el grupo al que pertenece. Podéis crear un archivo con touch:

touch nombrearchivo.txt

33 En Linux los usuarios pueden pertenecer a distintos grupos.

294


Es posible modificar archivos directamente desde el terminal con el editor vi, un pro-grama «espartano» con una interfaz poco intuitiva. Abrid un archivo de texto con:

vi nombrearchivo.txt

Podéis desplazaros por el archivo utilizando los cursores. Para modificar algo, debéis pulsar la tecla i (Insert), o a (Append) si queréis activar el modo de escritura. Para guardar los cambios tenéis que salir del modo de edición pulsando ESC y escribir:

:w

Para salir de vi debéis utilizar:

:q

Para analizar el contenido de un archivo de texto, utilizad el comando cat:

cat ./archivo_de_texto.txt

El comando cat muestra en pantalla todo el contenido del archivo. Si el archivo es muy largo y queréis desplazarlo podéis utilizar less, que funciona como un lector de archivos de texto:

less ./archivo_de_texto.txt

Dentro del terminal, para simplificar la escritura de comandos, podéis utilizar la tecla TAB que activa la función de autocompletar, la cual intentará completar automática-mente lo que estáis escribiendo. Es muy útil cuando deben escribirse largas rutas de carpetas, o cuando no nos acordamos de un comando. Os podéis desplazar por los comandos que ya habéis escrito utilizando las teclas de flecha «arriba» y «abajo».Para copiar un archivo debéis utilizar cp, indicando el archivo que se desea copiar y el nuevo destino:

cp ./miarchivo.txt /tmp/

En este caso, antes del nombre del archivo, aparece un punto y una barra inclinada: el punto indica vuestra posición actual. Podéis utilizar esta escritura también para ejecu-tar un archivo guardado en vuestra carpeta actual:

./inicia_mi_proceso.sh

El comando mv se comporta como cp y se utiliza para mover archivos de una posición a otra. También se puede utilizar mv para renombrar un archivo:

mv ./miarchivo.txt ./miarchivo2.txt

295


Para cancelar archivos y carpetas, se utiliza rm seguido del nombre del objeto que se desea eliminar. Prestad atención, porque aquí no hay papelera y un archivo eliminado es muy difícil de recuperar.

rm ./miarchivo.txt

Para forzar el movimiento de un archivo, añadid el parámetro f. Para eliminar una car-peta que contiene archivos añadid también el parámetro r (que significa «recursivo»):

rm –rf ./cartella1

ConsolaPara controlar lo que ocurre en la placa de Arduino, se suele utilizar el Serial Monitor para recibir (o enviar) información al microcontrolador. Dado que la placa Yún no se suele conectar con un cable USB, existe el objeto Console, que se comporta exacta-mente como el puerto Serial que utilizáis con el Serial Monitor. La consola os permite comunicaros con vuestro Arduino Yún mediante la conexión de red. Aquí tenéis un sencillo sketch de prueba:

#include <Console.h>void setup() Bridge.begin(); Console.begin(); while (!Console) Console.println("La consola está conectada");

int i = 0;

void loop() Console.println(i); delay(1000); i++;

Para utilizar la consola, debéis incluir su librería e inicializar el Bridge, fundamental para su funcionamiento. Tras haber iniciado la consola, debéis esperar a que esté preparada con un ciclo while(). En el loop() se muestra una secuencia de números. Para probar el sketch, lo compiláis, lo cargáis en Yún y después abrís el Serial Monitor para leer los mensajes. La consola también puede recibir los caracteres que envía el Serial Monitor.Este sería un sketch para controlar el encendido del LED en el pin 13 enviando las letras a o s («encendido» o «apagado»):

#include <Console.h>

void setup() Bridge.begin();

296


Console.begin(); while (!Console) Console.println("¡Conectado!"); pinMode(13, OUTPUT);

void loop() if (Console.available() > 0) int ch = Console.read(); if (ch == 'a') digitalWrite(13, HIGH); if (ch == 's') digitalWrite(13, LOW); delay(100);

Si llegan bytes desde el Serial Monitor, se pueden procesar con el método Console.available(). Los caracteres enviados se pueden leer con Console.read(). Dentro del loop() los caracteres se asignan a la variable ch utilizada para controlar el estado del LED. Si utilizáis el LED en el pin 13, no es necesario que construyáis ningún circuito: el LED incluido en la placa es de color rojo brillante y es suficientemente evidente.También os podéis conectar a la consola desde un terminal. Abrid uno y os conectáis a la Yún mediante ssh con el comando:


A continuación, tras haber efectuado el inicio de sesión, escribís:

telnet localhost 6571

telnet es un comando similar a ssh, pero que utiliza un nivel de seguridad menor. Esta instrucción se conecta a un servicio que se ejecuta en la misma placa Yún y que res-ponde al puerto 6571; localhost es un «atajo» para indicar la dirección de la placa o del ordenador con el cual estáis trabajando. Interrumpid la consola pulsando CTRL + Z (véase la Figura 11.5).

Servidor web sencilloArduino Yún puede funcionar como servidor web publicando páginas HTML que pue-den ser incluidas en el sketch.Cread un sketch vacío:

void setup() void loop()

297


Guardad el código con un nombre (por ejemplo, “yun-webserver”), después, abrid la carpeta del sketch y cread un directorio denominado “www”. Cread una página HTML dentro de esta última y la renombráis como “index.html”.

Figura 11.5 - Uso de la consola mediante telnet.

Todo el contenido de esta carpeta será copiado en la tarjeta SD incluida en Arduino y publicada en el servidor web de Linux. Este procedimiento funciona solo si se carga el sketch vía WiFi. Tras haber cargado el sketch y haber comprobado que todo ha ido bien, abrid un navegador e insertad la dirección http://arduino.local/sd/yun-web-server. En este caso, se supone que habéis bautizado a vuestro Arduino Yún con el nombre “arduino” y que el sketch se denomina “yun-webserver”. Si en la carpeta www existe una página index.html, debería aparecer en el navegador.Si no sabéis cómo crear una página web, seguid las siguientes instrucciones:

• cread un archivo de texto denominado “index.html”;• moved el archivo a la carpeta www de vuestro sketch;• abrid el archivo index.html con un editor como Notepad (no Word o similares);• escribid el código HTML para la página y, cuando acabéis, guardadla.

Un archivo HTML está formado por una serie de etiquetas (tags), es decir, de pala-bras especiales delimitadas por los signos < y >. La regla general es que las etiquetas

298


siempre van a pares: una es de apertura y otra, de cierre. Por ejemplo, un documento empieza siempre con una etiqueta <HTML> y acaba con </HTML>. La etiqueta de cierre se reconoce porque, después del símbolo <, muestra una barra /. Para que un archivo pueda ser interpretado por un navegador, se necesitan pocas cosas: basta con insertar un par de etiquetas <BODY> con el texto que hay que mostrar. Para destacar un título, podéis utilizar un par de etiquetas h1. Las etiquetas pueden ser «anidadas» unas den-tro de otras.Este sería un archivo index.html sencillo:

<html><body> <h1>Hello Web!</h1></body></html>

Después de haber copiado el código HTML en el archivo index.html, lo guardáis y hacéis doble clic sobre él para abrirlo con el navegador y poder admirar vuestra obra.Volvamos a la Yún: podéis comprobar qué le ha ocurrido a la tarjeta SD tras haber car-gado el sketch con la página web. Para ello, abrís un terminal y os conectáis a Arduino; después, localizáis el punto en el cual ha sido «montada» la tarjeta SD: normalmente, las tarjetas de memoria pueden visualizarse como si fueran subdirectorios dentro de mnt. Después, escribís:

cd /

para acceder a la root del sistema.A continuación, solicitáis un listado de archivos y directorios mediante:

ls

La tarjeta de memoria se encuentra normalmente en la posición /mnt/sd o en su equi-valente /mnt/sda1 (son dos alias o sinónimos, también conocidos como “links simbó-licos”). Después de haber cargado el sketch, el contenido de la carpeta www que ha-béis creado acaba en /mnt/sd/arduino/yun-webserver.En ocasiones, tras la carga del sketch, aparece un error en la consola de Arduino, en cuyo caso, las páginas HTML no serán publicadas. Apagad Arduino y extraed la tar-jeta de memoria microSD. Insertadla en vuestro ordenador y comprobad que se haya formateado de manera correcta (FAT o FAT16). Intentad crear vosotros la carpeta ar-duino y, en su interior, la carpeta www; después volved a insertar la tarjeta en la Yún y reiniciadla.

299


Páginas web dinámicasUtilizando el Bridge, es posible publicar servicios web proporcionados directamente por la placa Yún. Podéis leer el estado de los pines digitales o analógicos y vincularlos a una dirección web. Gracias a las nuevas librerías para la placa Yún, resulta muy fácil vincular todo cuanto ocurre en la placa con la parte web ofrecida por Linux.Para crear un servicio web, es preciso incluir las librerías Bridge, YunServer y Yun-Client:

#include <Bridge.h>#include <YunServer.h>#include <YunClient.h>

Mediante YunServer, se crea un servidor completo y configurable personalizado. Un servidor siempre está conectado a una dirección IP y a un puerto. YunServer se inicia-liza con:

server.listenOnLocalhost();server.begin();

De este modo, el servidor está activo y espera la llegada de una solicitud de datos por parte de un cliente. Un cliente puede ser, por ejemplo, un navegador que solicita una dirección concreta, como http://arduino.local/arduino/valor_del_sensor_x.Esta dirección proporciona el “valor del sensor x” interpretado por la placa y lo vincula a una dirección web. Para utilizar el servicio, basta con escribir la dirección en un na-vegador. El servidor se pone en espera del cliente con:

YunClient client = server.accept();

Cuando llega una solicitud, se crea un objeto YunClient. Si el cliente existe y está pre-parado para comunicarse, se puede extraer el tipo de solicitud que está dirigiendo al servidor y, después, se proporciona una respuesta:

if (client) String command = client.readString(); command.trim(); if (command == "temperature") int val = analogRead(A1); client.print(val); client.stop();

En este caso, la solicitud es temperature y la respuesta consiste en la lectura del valor presente en la entrada analógica A0 de Arduino. El valor detectado se envía mediante el método print() y la comunicación se interrumpe con stop().

300


Este sería el sketch completo:

#include <Bridge.h>#include <YunServer.h>#include <YunClient.h> YunServer server; void setup() Bridge.begin(); server.listenOnLocalhost(); server.begin(); void loop() YunClient client = server.accept(); if (client) String command = client.readString(); command.trim(); if (command == "temperature") int val = analogRead(A0); client.print(val); client.stop(); delay(50);

Cargadlo en la Yún y abrid un navegador con la dirección http://arduino.local/ardui-no/temperature. YunServer proporciona directamente el servicio, por lo que en la di-rección no hay que incluir sd como en el ejemplo anterior.

Figura 11.6 - Página web publicada por Arduino Yún con la lectura del dato proporcionado por el servicio temperature.

301


Se puede crear una página HTML que lea un valor desde Arduino y se actualice sola, regularmente, mostrando las informaciones. Para conectar una página web al servicio, debéis crear una carpeta con el nombre “www” dentro del sketch. En esta carpeta creáis un archivo denominado “index.html”, el cual deberá interpretar el valor publica-do por el servicio y, después, utilizarlo para modificar el contenido presentado. ¿Cómo podemos hacerlo en una página HTML? Debemos utilizar una librería en JavaScript, un lenguaje de programación que se utiliza, entre otras cosas, en páginas web. Existen muchas librerías JavaScript que podrían desarrollar esta tarea, como jQuery, pero para un proyecto muy sencillo podemos utilizar también una versión “reducida” de jQuery: Zepto (http://zeptojs.com). Descargad el archivo zepto.js y guardadlo en la carpeta www dentro del sketch. Así debe ser la página web denominada “index.html”:

<!DOCTYPE html><head> <script type="text/javascript" src="zepto.js"></script> <script type="text/javascript"> function refresh() $('#content').load('/arduino/temperature'); </script></head><body onload="setInterval(refresh, 1000);"> <span id="content">Waiting for Arduino...</span></body>

A diferencia de la página del ejercicio anterior, aquí hay una sección head en la cual se ubican los script. El primer par de etiquetas script añade la librería a la página (un poco como include en Arduino) y el segundo par cierra el código que ejecuta tota la tarea:

function refresh() $('#content').load('/arduino/temperature');

La instrucción queda recogida en una función denominada refresh(). En la función, la librería zepto carga el valor publicado por el servicio web que hemos vinculado a la dirección /arduino/temperature y lo escribe en el elemento con id="content". Si os desplazáis por el código, veréis un par de etiquetas span con id="content". La etiqueta body contiene una directiva onload que, cuando se carga la página, llama a la función refresh(). Para actualizar el dato cada 1000 milisegundos, la función setIn-terval() llama a refresh().Compilad y cargad el sketch en Arduino Yún; después acceded con el navegador a la dirección http://arduino.local/sd/yun-temperature para ver la página de visuali-zación del dato.

302


ResetLa placa cuenta con tres botones para el reset. Estos botones están situados cerca de las esquinas de la placa. El botón Yún RST, situado detrás de los pines de las entradas analógicas, realiza el reinicio del sistema OpenWrt. El botón RESET para el sketch car-gado en el ATmega32u4 se encuentra junto al puerto Ethernet y debe pulsarse dos ve-ces en rápida secuencia. En este caso, veréis el LED L13 (rojo) parpadear brevemente.Para eliminar la configuración del WiFi y dejar la placa con sus parámetros originales, debéis utilizar el botón WLAN RST, que se encuentra junto al conector USB (tipo A). Debéis pulsarlo como mínimo durante 5 segundos (y como máximo durante 30). Esto es útil si la placa se desplaza y ya no alcanza la red WiFi. Tras haberla reseteado, la Yún se reinicia en modo Access Point emitiendo una red tipo “Arduino Yun-xxxxxxxxxxx”. Conectaos a ella con vuestro ordenador y volved a configurar la placa.Al pulsar WLAN RST durante al menos 30 segundos volveréis a decorar el estado del sistema operativo con la imagen actual (o con la última actualización cargada). Es como forzar una reinstalación del sistema operativo.

BridgeLa parte más interesante de Arduino Yún es el Bridge, una librería que podéis utilizar directamente en vuestros sketch y que permite que el hardware gestionado por el ATmega32u4 se comunique con Linux y, por tanto, con Internet. Ya habéis podido ver el Bridge en los ejemplos de la introducción y, seguramente, habréis observado la ex-trema simplicidad de uso de sus clases. Crear un servicio web o publicar un sitio web dinámico no es algo que esté al alcance de cualquiera, sobre todo de aquellos que «no se encuentran en el sector», pero habéis podido comprobar la extrema simplificación presentada por el equipo de Arduino. Gracias al Bridge, podéis interactuar con proce-sos y archivos presentes en el sistema Linux, o bien conectar llamadas procedentes de Internet (o de Web) con acciones de hardware efectuadas por ATmega. Por ejemplo, podéis encender un LED solicitando una dirección web. Para los más expertos, existe también la posibilidad de escribir programas en Python para Linux y controlarlos des-de el sketch.Para comprobar de inmediato la potencia de esta librería, cargad el ejemplo Bridge que encontraréis en Examples > Bridge. El sketch «publica» vuestro Arduino Yún en Red, de manera que cualquier pin pueda ser controlado utilizando un navegador. An-tes de cargar el ejemplo, comprobad que habéis deshabilitado la contraseña para los servicios web accediendo a la consola administrativa de Yún. Después de haber car-gado el sketch, podréis encender un LED llamando a las siguientes direcciones con un navegador:

303


• http://arduino.local/arduino/mode/13/output;• http://arduino.local/arduino/digital/13/1;• http://arduino.local/arduino/digital/13/0.

La primera llamada configura el pin como «salida», las otras modifican el estado del puerto 13 encendiendo y apagando el LED. Solicitando otras direcciones web, es posible leer el estado de un pin analógico o configurar un PWM (las instrucciones se encuen-tran al inicio del sketch).La librería Bridge dispone de distintas clases:

• YunClient – es una clase de “apoyo” para todos los tipos de cliente;• YunServer – es una clase genérica para crear servidores;• HttpClient – realiza un cliente HTTP con el cual se pueden llamar servicios y

páginas web;• Mailbox – para intercambiar mensajes con un mecanismo similar al correo;• Process – para controlar programas en ejecución en Linux;• Console – para utilizar el Serial Monitor también en Red;• FileIO – para leer, escribir y gestionar los archivos incluidos en la tarjeta SD;• Temboo – permite interactuar con el sitio Temboo (https://temboo.com/), que fa-

cilita el uso de servicios web complejos, como Twitter, Facebook, Dropbox, etc.;• Spacebrew – es una clase para interactuar con Spacebrew (http://docs.space-

brew.cc/), un protocolo para conectar entre sí objetos interactivos.

Algunas de estas clases ya las habéis podido utilizar, por lo que ahora os propongo profundizar algo más para cubrir los argumentos principales.

HttpClient

Esta clase simplifica la lectura de páginas web con Arduino: con pocas líneas, es po-sible realizar llamadas http simulando un navegador. Esto es posible porque es Linux quien lleva a cabo la operación y no el código del sketch. Linux está más preparado para realizar este tipo de operaciones, que para un simple microcontrolador son más complicadas.Este sería un sketch para leer la página de inicio de Google: comparadlo con uno de los ejemplos HttpClient para la Ethernet Shield para apreciar su simplicidad.

#include <Bridge.h>#include <HttpClient.h>

void setup() Bridge.begin(); Console.begin(); while (!Console);

304


HttpClient client; client.get("http://www.google.com");

while (client.available()) char c = client.read(); Console.print(c); Console.flush();

void loop()

Mailbox

Mailbox es un sistema para intercambiar mensajes de manera asíncrona: una especie de correo electrónico rudimentario. Esto significa que podéis enviar un mensaje a Ar-duino y este, cuando lo desee, lo interpreta extrayéndolo del buzón de correo.El buzón de correo está vinculado a la dirección web http://arduino.local/mailbox. Para enviar un mensaje, debéis abrir el navegador y añadir el texto detrás de la dirección del buzón (por ejemplo, http://arduino.local/mailbox/Hello Web!).Este es el código para gestionar el buzón de correo:

#include <Mailbox.h>

void setup() Bridge.begin(); Mailbox.begin();

Console.begin(); while (!Console); Console.println("Mailbox\n");

void loop() if (Mailbox.messageAvailable()) while (Mailbox.messageAvailable()) String msg; Mailbox.readMessage(msg); Console.println(msg); delay(3000);

No os olvidéis de incluir la librería Mailbox.h ni de inicializarla primero con Bridge.begin() y, después, con Mailbox.begin(). Para funcionar, esta librería necesita el Bridge. En el loop() se controla el buzón de correo cada 3 segundos mediante la función Mail-box.messageAvailable(). Cuando llega un mensaje, se puede extraer con readMessage(). Abrid la consola para ver los mensajes recibidos.

305


También es posible enviar mensajes desde el sketch del buzón de correo; en este caso, Linux es quien extrae los mensajes, siendo necesario escribir un script en Python que se conecte a la consola y extraiga los mensajes enviados.Modificad el sketch para que envíe una serie de números al buzón de correo: los nú-meros deben ser convertidos en cadenas. Así es como se modifica el sketch del ejem-plo anterior:

#include <Mailbox.h>

void setup() Bridge.begin(); Mailbox.begin();

Console.begin(); while (!Console); Console.println("Mailbox\n");

int i = 0;void loop() Mailbox.writeMessage(String(i)); delay(3000); i++;

Cargáis el sketch y abrís el Serial Monitor para aseguraros de su funcionamiento. Se-guidamente, os conectáis a la Yún con un terminal y creáis un archivo de texto con:

touch mailbox.py

Lo abrís con el editor vi:

vi mailbox.py

y copiáis el siguiente script en Python:

import socketimport jsons = socket.socket(socket.AF_INET, socket.SOCK_STREAM)s.connect(('127.0.0.1', 5700))result = json.loads(s.recv(1024))print results.close()

Pulsáis ESC, guardáis y salís con :wq. El script se inicia con:

python mailbox.py

Si el sketch se está ejecutando, el programa en Python extrae los mensajes del buzón de correo y los muestra en pantalla.

306


Process

La clase Process sirve para ejecutar procesos, programas o comandos en el sistema Linux. También es posible pasar parámetros y recuperar el texto producido por la eje-cución del comando. Con este sketch, podemos llamar al comando ls –l y leer el resultado:

#include <Process.h>

void setup() Bridge.begin(); Console.begin(); while (Console) Console.println("Ok...");

void loop() Process p; p.begin("ls"); p.addParameter("-l"); p.run(); while (p.available() > 0) char c = p.read(); Console.print(c); Console.flush(); delay(5000);

Creáis un proceso con Process y, a continuación, especificáis la operación que hay que llevar a cabo con begin(). En este ejemplo, el comando llamado es ls. Los parámetros se añaden con el método addParameter(). Cuando el código está preparado, se puede ejecutar el proceso con run(). Para leer la salida producida por el proceso, basta con tratar el objeto creado como si fuera un puerto serie. Con run(), el microcontrolador espera el final del proceso. Es posible iniciar una operación sin esperar su finalización con runAsynchronously(). Para controlar si el proceso iniciado todavía se está ejecutan-do, podéis utilizar running(). No se puede ejecutar más de un proceso a la vez.

FileIO

Con FileIO podéis interactuar con archivos guardados en la tarjeta SD. Tras haber ini-cializado el objeto FileIO con el método begin(), podéis escribir, leer o eliminar archi-vos y directorios. Este sería un sencillo ejemplo para escribir un archivo de texto:

#include <FileIO.h>

void setup() Bridge.begin(); Console.begin();

307


while (Console) FileSystem.begin(); Serial.println("Ejemplo FileIO\n");

File file = FileSystem.open("/mnt/sd/test.txt", FILE_APPEND); if (File) file.println("Hello!"); file.close();

void loop()

Después de haber cargado el sketch, os debéis conectar a un terminal y situaros en la carpeta que corresponde a la tarjeta SD: /mnt/sd. Comprobad si el archivo existe utilizando ls y leed su contenido con:

cat test.txt

Este ejemplo es útil para llevar a cabo un data logger, es decir, un circuito que extrae datos y los escribe en un archivo log de la tarjeta SD.

¿Estáis preparados para empezar?En este breve capítulo habéis podido conocer las múltiples potencialidades de Ardui-no Yún. Con esta placa es muy sencillo generar proyectos complejos y con conexión a Internet. Podéis encontrar más información y algunos ejemplos en su sitio oficial y en la página exclusiva de la librería Bridge (http://bit.ly/yunbridge).

309

Espero que este libro os haya sido útil y que lo tengáis en vuestro puesto de trabajo para poder echarle un vistazo rápido cuando lo necesitéis. Como habéis podido com-probar, el mundo de Arduino es muy amplio y está en constante evolución. Manteneos siempre actualizados con los múltiples recursos online. En Internet encontraréis mu-chos sitios de personas apasionadas deArduino con vídeos, tutoriales y lecciones de todo tipo.En el libro no he podido tratar todos los tipos de sensores, actuadores y dispositivos existentes: sin embargo, si conocéis las bases, no tendréis ningún problema para ha-cer funcionar cualquier cosa con vuestro Arduino. Ahora que sabéis cómo utilizarlo, podréis realizar todos los proyectos que os podáis imaginar: máquinas, drones, impre-soras, robots o simples termostatos. No os detengáis con Arduino: existen muchas otras placas de prototipado que utilizan microcontroladores de distintos tipos. Intentad programar los microcontroladores PIC o AVR, o bien utilizar una Raspberry Pi, una BeagleBone o una placa Intel Edison.Buscad la inspiración en vuestros intereses y profundizad en aquellos temas que os suscitan más curiosidad. Hoy en día es muy sencillo aprender a hacer cosas: no os detengáis y no os rindáis jamás.Podéis encontrar más detalles sobre este libro y el código fuente de los sketch en mi sitio/blog www.zeppelinmaker.it/arduino y en la página arduino.madeformakers.it.

Conclusión

311

En los ejemplos electrónicos mostrados en el libro, se han utilizado resistencias indi-cando directamente su valor, sin explicar cómo reconocerlas. En esta breve sección, explicaré cómo leer el valor de una resistencia. Para tener una visión más completa de las competencias electrónicas necesarias para desarrollar circuitos, os aconsejo echar un vistazo al libro Elettronica per maker.Los resistores reducen el flujo de corriente porque están construidos con materiales que ofrecen una cierta resistencia a su paso y, a menudo, se parecen a tubos con pasos estrechos. Un valor bajo de resistencia equivale a un tubo poco estrecho o a un mate-rial que no opone muchas dificultades al paso de la corriente eléctrica. Un valor eleva-do de resistencia se obtiene cuando en el material fluye poca cantidad de corriente. La resistencia, es decir, la dificultad con la que la corriente atraviesa un material, se mide en ohms (cuyo símbolo es la letra griega Omega: Ω).El cobre es un buen conductor porque tiene un valor de resistencia muy bajo, casi nulo: 0,0000000169 ohms por metro. Los resistores que se utilizan en los circuitos electrónicos tienen valores que van desde algunos ohms hasta millones. El tipo de resistor más utilizado se parece a un pequeño würstel con los extremos hinchados y con bandas de colores que sirven para identificar su valor. Normalmente, las bandas son cuatro y una de ellas, situada en un extremo, es de color dorado. Para leer la re-sistencia, colocad la banda dorada a vuestra derecha y leed el resto empezando por la izquierda, tomando como base el contenido de la Tabla A.1.

Tabla A.1 - Código de colores para la lectura de los resistores.

Color Valor Color Valor

Negro 0 Verde 5Marrón 1 Azul 6

Rojo 2 Violeta 7Naranja 3 Gris 8Amarillo 4 Blanco 9

ApéndiceLeer el valor de una resistencia

A

312


Así es como se lee una resistencia con las bandas de color marrón, negro, amarillo y dorado:

• sostened la resistencia con la banda dorada a la derecha;• leed las bandas de colores de izquierda a derecha;• la primera banda es de color marrón, por lo que debéis escribir “1” en un papel;• la segunda banda es negra, por lo que debéis escribir “0”;• la tercera banda es amarilla, por lo que debéis escribir “4”;• en el papel habéis escrito “1 0 4”, que todavía no es el valor de la resistencia;

• borrad la tercera cifra y sustituidla por el número de ceros correspondiente a su valor. Sustituid el número “4” con cuatro ceros, es decir, “0 0 0 0”;

• la resistencia vale 100.000 ohms.

Figura A.1 - Lectura del valor de una resistencia.

Figura A.2 - Leed las bandas del resistor y escribid en un pa-pel el código correspondiente a cada color.

Figura A.3 - Sustituid la tercera cifra con el correspondiente número de ceros.

313

Leer el valor de una resistencia Apéndice A

Sin embargo, en lugar de escribir 100.000 Ω, los electrónicos prefieren utilizar 100 kΩ. Los números hasta el 999 se escriben sin abreviación; los números por encima del mi-llar se escriben acompañando el símbolo Ω con una “k” que significa “kilo-”. Así:

1 kΩ = 1.000 Ω

10 kΩ = 10.000 Ω

100 kΩ = 100.000 Ω

Después de los “kilo-” están los “mega-”, indicados con una “M”. Para un resistor de un millón de ohms, no escribiréis 1.000.000 Ω, sino 1 MΩ.A veces los símbolos “k” y “M” se utilizan como si fueran comas:

2k2 = 2.200 Ω

4k7 = 47.000 Ω

3M3 = 3.300.000 Ω

La última banda de color indica la precisión del valor de la resistencia. Normalmente siempre es de color dorado, que significa que el valor puede variar más o menos un 5 %. Si la banda es de color plateado, la tolerancia es del 10 %. Existen además com-ponentes más precisos, del 1 % o 2 %: tienen cinco bandas en lugar de cuatro y se leen con un procedimiento similar al que acabamos de ver.No existen resistores de cualquier valor imaginable, puesto que se necesitarían alma-cenes de dimensiones enormes. Las resistencias, así como casi todos los componen-tes eléctricos, se pueden adquirir solo en una serie limitada de valores. Los valores admitidos respetan esta gama: 1, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 10. Nunca encontraréis una resistencia de 20 Ω, pero sí de 22 Ω o de 18 Ω. No existen componentes de 500 kΩ, pero sí de 470 kΩ o de 560 kΩ.A continuación, intentaréis leer las resistencias de la Figura A.4 (encontraréis las so-luciones al final del Apéndice).

Figura A.4 - Intentad leer los valores de al-gunos resistores.

314


El símbolo que se utiliza para los resistores es una línea en zigzag, que recuerda a un camino tortuoso. En ocasiones también se utiliza un simple rectángulo.

Junto al símbolo se puede indicar también el valor de la resistencia y el nombre pro-porcionado por el diseñador (por ejemplo, R1). En el caso en que se indiquen solo los nombres, el esquema eléctrico va acompañado de una lista de materiales en la cual, junto a cada nombre, se indican las características del componente.

Soluciones• rojo-rojo-marrón = 220 Ω• marrón-negro-negro = 10 Ω• marrón-negro-dorado-dorado = 1 Ω

Figura A.5 - El símbolo de un resistor es una línea en zigzag, aunque en ocasiones se utiliza un rectángulo.

315

Il manuale dell’inventore, 1987El manual con el cual empecé a estudiar electrónica y a hacer experimentos. Un libro ilustrado y muy intuitivo que habla de física, química y electrónica. El libro está en italiano.

Gustavo Buscher, Elettrotecnica figurata, Hoepli, 1947Es un manual de electrotecnia ilustrada. Cada concepto se explica mediante analogías hidráulicas. Está descatalogado desde hace tiempo.

Paul Scherz, Practical Electronics for Inventors, McGraw-Hill, 2006Un libro completo sobre electrónica. Cada argumento se explica de manera sencilla y, después, tratado hasta el más mínimo detalle. Adecuado para el principiante y el maker experto, porque sigue siendo una fuente de inspiración gracias a los múltiples ejemplos prácticos. El libro está en inglés.

Jacob Millman, Arvin Grabel, Microelectrónica, McGraw-HillSe trata de un libro de electrónica universitario, muy completo y profundo. Para leerlo, se precisan conocimientos de matemáticas y física.

Massimo Banzi, Introducción a Arduino, O’Reilly Media-Anaya, 2012La guía introductoria de Arduino, escrita por su fundador. Un pequeño libro que os enseña todo aquello que hay que saber para empezar a caminar por el mundo de Arduino.

Tom Igoe, Making Things Talk – Practical Methods for Connecting Physical Objects, O’Reilly Media, 2007Este libro es maravilloso: entendedor y completo. Os explica cómo tomar confianza con sensores, actuadores y sistemas de transmisión de datos. Los proyectos se des-criben de manera ejemplar y los resultados son siempre extraordinarios. En inglés.

Bibliografía recomendada

316


Charles Platt, Make: Electronics – Learning Through Discovery, O’Reilly Media, 2009Un libro que explica la electrónica de manera sencilla e intuitiva. Las explicaciones van siempre vinculadas a casos prácticos. Bien escrito y muy comprensible. En inglés.

Herman Schutte, Bi-directional level shifter for I2C-bus and other systems, APPLICATION NOTE - AN97055, Philips Semiconductors Systems Laboratory Eindhoven, The Ne-therlands, http://www.nxp.com/documents/application_note/an97055.pdf.

Vínculos y referencias onlineEsta es una breve lista de distribuidores y vendedores de componentes electrónicos:

• RS Components;• Farnell element14;• Robot Italy;• Seeed Studio;• Arduino;• Robot Store;• Mouser Electronics;• DigiKey Electronics;• SparkFun Electronics.

Vínculos útiles• En highlowtech.org - http://bit.ly/makersattiny, encontraréis tutoriales para la

programación de los ATtiny.• Las instrucciones para fabricar el programador FabISP están publicadas en el

sitio del MIT, http://bit.ly/makersfabisp.• Os remito también a mi sitio web, www. zeppelinmaker.it, en el cual publico

posts relacionados con la creación digital. El sitio dedica una sección a este libro, en la cual encontraréis explicaciones y proyectos.

• Stack Exchange, en cambio, es un sitio donde se publican preguntas y dudas para obtener respuestas de los usuarios: http://electronics.stackexchange.com/.

• En el sitio Instructables (http://www.instructables.com/) podéis encontrar la descripción completa de proyectos electrónicos, con las instrucciones detalla-das para llevarlos a cabo.

317

Bibliografía recomendada

Especificaciones técnicasPara buscar las hojas de especificaciones técnicas, yo utilizo el sitio de RS Compo-nents o de Farnell. En la página de cada componente se adjuntan los archivos técnicos con las medidas y sus características. No es preciso estar registrado en el sitio para acceder a estos archivos.

App para smartphoneElectroDroid: es una aplicación para Android que todo electrónico debería tener en su teléfono. La aplicación contiene fórmulas, pinouts y múltiples herramientas para resolver problemas cotidianos y frecuentes para los diseñadores.

319

Bootloader: es un pequeño programa que puede ser ejecutado en condiciones espe-ciales. El bootloader de Arduino se despierta cada vez que llegan datos al puerto USB; si reconoce el envío de un nuevo programa, lo escribe en la flash del microcontrolador. El bootloader puede escribir directamente en la flash y, por tanto, programar el micro-controlador. Gracias al bootloader, no es preciso utilizar ningún programador especial.

Convertidor análogico-digital (ADC): es un circuito que puede estar dentro de un microcontrolador y sirve para transformar una señal analógica en una digital, es decir, en un número o en una secuencia de bits.

Convertidor digital-analógico (DAC): es lo contrario a un ADC. Convierte un número binario en un valor analógico incluso en un cierto intervalo de tensiones. En los pasos de digital a analógico (y viceversa), es inevitable que se pierda siempre una parte de la se-ñal. Si se toman precauciones, es posible reducir al mínimo estos errores de conversión.

Entorno Integrado de Desarrollo o Integrated Development Environment (IDE): es un programa, normalmente gráfico, para escribir software de manera eficiente. El edi-tor para la escritura del código está especializado en la escritura de software y ayuda al programador con muchas funciones y herramientas, asistiéndolo en cada fase del trabajo. Normalmente, los IDE ofrecen también un depurador con el cual analizar la ejecución de un programa: muy útiles para localizar errores y problemas. Existen de-puradores para conectarse a los microcontroladores y ejecutar en remoto el desarrollo de un firmware.

Entrada analógica: algunos pines del microcontrolador están conectados a conver-tidores analógico-digitales y, por tanto, pueden proporcionar al software una lectura de la señal presente en el pin. En las placas Arduino, estos pines son normalmente distintos a los otros y se encuentran marcados con una letra A seguida de un número. Los pines analógicos, por lo general, se pueden configurar también para ser utilizados como pines digitales.

Glosario

320


Firmware: es un programa cargado directamente en un chip. No es exactamente un software, puesto que el usuario no puede modificarlo fácilmente.

FTDI (Future Technology Devices International): es una sociedad escocesa especiali-zada en la producción de circuitos integrados para las tecnologías USB. Es reconocido su convertidor USB-Serial.

Jumper: es un pequeño cable dotado en sus extremos de dos pequeñas bayonetas que pueden ser fácilmente acopladas en los cabezales de Arduino.

Memoria EEPROM o Electrically Erasable Programmable Read-Only Memory: es una memoria que puede mantener pequeñas cantidades de información durante mucho tiempo, incluso cuando no está alimentada. Se puede reescribir utilizando señales eléctricas.

Memoria Flash: en los microcontroladores, la memoria flash se utiliza como disco duro de un ordenador convencional. Es una memoria en estado sólido, particularmen-te rápida, que puede guardar la información durante mucho tiempo. En los microcon-troladores, se ocupa de la escritura del programa que se ejecutará. Una parte de la memoria flash se puede reservar para el bootloader.

Memoria RAM o Random Access Memory: es la memoria volátil que utiliza la CPU del microcontrolador para ejecutar la operación actual del programa y para almacenar va-lores temporales y variables. Pierde su contenido cuando el chip deja de ser alimentado.

Microcontrolador, µC, MCU (Micro Controller Unit): un microcontrolador es un pe-queño ordenador guardado en un chip individual. Es un sistema autónomo, formado por memoria RAM, memoria Flash, EEPROM, un circuito de sincronización, conver-tidores analógico-digitales y digital-analógicos, temporizador, puertos de comunica-ción de distintos tipos. Las placas Arduino son básicamente soportes prácticos, que proporcionan la alimentación y las comunicaciones básicas para utilizar los microcon-troladores Atmel.

Pin: es el nombre inglés de las «patas» del chip.

Pines digitales de I/O o General Purpose I/O (GPIO): todos los microcontroladores se comunican con el mundo exterior mediante pines que pueden comportarse como entradas o salidas. El comportamiento de los pines se define en el software que se carga en el microcontrolador, de forma que la placa pueda tener un comportamiento dinámico y flexible. Algunos pines tienen papeles especiales: pueden crear señales PWM, exponer un puerto serie o desarrollar otras funciones específicas.

321

Glosario

Pulse Width Modulation (PWM): algunos pines son capaces de generar una señal de onda cuadrada donde la relación entre los tiempos de encendido y apagado puede va-riar al azar de 0 a 100 %. Cuando el valor es 0, la señal es completamente nula; cuando el valor es igual a 100, la señal está al máximo. Si la señal está al 50 %, el tiempo «en-cendido» equivale al tiempo «apagado». La señal PWM es adecuada para controlar motores eléctricos o para controlar la intensidad de un LED de forma precisa.

Serial Peripheral Interface (SPI): es un puerto serie muy conocido, utilizado por un chip para comunicarse con otros chips. Fue presentado por Motorola y cuenta con un dispositivo maestro y varios dispositivos clientes. La comunicación puede efectuarse en dos direcciones.

Shield: las tarjetas de expansión de Arduino se denominan así. Presentan un pinout compatible con los pines de Arduino y se acoplan una encima de otra. Cada shield ofrece una funcionalidad completa. Otras plataformas, distintas a Arduino, utilizan otros nombres, como las capes de las placas BeagleBone.

Sincronía o Clock: es una señal digital, formada por impulsos o por una onda cuadra-da con una frecuencia muy regular. Se utiliza en los circuitos digitales para coordinar todas las operaciones. Para los chips Atmel utilizados en las placas Arduino, normal-mente es de 16 MHz, aunque en algunas placas puede ser de 8 MHz. Las placas que utilizan chips más evolucionados, con tecnología ARM, llegan a los 40 MHz, mientras que en las soluciones con SoC o en las placas Intel se alcanzan los GHz.

Universal Asynchronous Receiver-Transmitter (UART): es un puerto serie que, en su forma más simple, está formado por dos archivos, uno para transmitir y otro para recibir datos. Algunos microcontroladores pueden tener más de un puerto.

323

Símbolos1N4005, 2451N4007, 2452N2222, 2372N7000, 2614N25, 206, 24774HC164, 15374HC165, 15674LS47, 1454511, 145

Aabs, 118access point, 282aceleraciones, 221acelerómetro, 221acoplador óptico, 206AH49E, 213alcohol, 212amplificador operacional, 205analogRead, 109, 189, 202analogReference, 189

DEFAULT, 189EXTERNAL, 189INTERNAL, 189

analogWrite, 103, 129, 250analogWriteResolution, 250AR9331, 30arduino

analogread, 197analogwrite, 198delay, 198delaymicroseconds, 198

Índice analítico

digitalread, 197digitalwrite, 197micros, 198millis, 198pinmode, 197pulsein, 198shiftout, 198

Arduino~, 263.3 V, 255V, 25101, 392009, 27alimentación, 24AREF, 25BT, 38Diecimila, 27Due, 31entradas analógicas, 26Esplora, 35Ethernet , 29FIO, 33Galileo, 38ICSP, 26Leonardo, 28Mega, 28Mega ADK, 35Micro, 31Mini, 32Nano, 32NG, 27Pro, 37Pro Mini, 32

324


reset, 25Robot, 36SPI, 26Tian, 30Tre, 36UNO, 24VIN, 25Yún, 30Zero, 37

Arduino Ethernet, 275ArduinoISP, 190Arduino Yún, 285AREF, 189ARM, 18array, 74, 258asm, 169assembler, 59, 169AT, 281

comandos , 270Atheros, 30Atheros AR9331, 285ATmega32u4, 285ATmega168, 27ATmega328, 23, 192ATmega644P, 40attachInterrupt, 164ATtiny, 41, 192, 194, 197ATtiny85, 194automoción, 286AVR, 18avrdude, 192, 193AVRISP, 190

BBanzi Massimo, 13bare minimum, 88Barragán Hernando, 15base, 236batería, 178batería tampón, 225baudios, 254bit, 121, 253bitClear, 123bit de parada, 256bit de paridad, 256

bitRead, 123bitSet, 123BJT, 235Blink, 54, 129bloques, 63bluetooth, 269Bluetooth, 30Bluetooth Mate Silver, 270bobina, 238booleano, 75bootloader, 17, 57, 166, 185, 190, 198, 319botón, 101, 134

analógico, 139sin resistencia, 136

breakout board, 45bridge, 302Bridge, 286brown out detect, 194BRT21, 241brújula, 222BTA08-400, 241buffer, 258butano, 212byte, 70, 121

Ccadena, 71campo magnético, 212, 222canal, 255canal de transmisión, 253carácter, 71carga eléctrica, 214cargar un sketch, 88case, 78cat, 294CC3000, 281cd, 292char, 71chgrp, 293chmod, 293chown, 293ciclo, 79circuito integrado, 17CISC, 18ciudades inteligentes, 286

325

Índice analítico

clase, 160clave isp, 185CNC, 19CO, 212codificador, 203código, 48código máquina, 169colector, 236comentarios, 55, 69compilador, 60compilación, 60comunicaciones, 253condensador variable, 201condición, 75consola

available, 296read, 296

Console, 295constrain, 119constructor, 160contadores, 172, 182

clear timer on compare match, 175counter control registers, 173CTC, 175overflow, 174TIMER1_COMPA_vect, 175TIMER1_OVF_vect, 174watchdog, 176

contraseña, 287Conversiones, 124convertidor analógico-digital, 319Convertidor de nivel, 260convertidor digital analágico, 319convertidor digital-analógico, 250corchetes

paréntesis, 68corrientes de Foucault, 238, 245cos, 120cp, 294cruce por cero, 240Cuartielles David, 15cuarzo, 198cursor, 150

DDAC0, 250DAC1, 250data logger, 225, 230, 307 datos, 225debouncing, 138define, 115delay, 111delayMicroseconds, 111despertar, 178detachInterrupt, 165DHCP, 276DHT11, 209digitalPinToInterrupt, 164digitalRead, 101digitalWrite, 96diodo, 245diodo de protección, 238dirección IP, 274, 275, 287dirección mac, 275directiva, 67display, 143

I2C, 151LCD, 148serial, 152siete segmentos, 143

distancia, 216divide y vencerás, 63divisor, 205, 207divisor de tensión, 260DMX, 284domótica, 274, 286double, 71do-while, 79driver, 50, 246drones, 19DS1307, 225DS1804, 248duración, 178

Eecho, 220EEPROM, 166EEPROM.h, 167eje motor, 203

326


electroimán, 238elemento calefactor, 211elevador de tensión, 262emisor, 236entrada

analógica, 194digital, 194

ESP8266, 281etanol, 212ethernet, 274

shield, 275Ethernet, 285EthernetClient, 277EthernetServer, 280etiquetas electrónicas, 228

FF(), 169FAB, 14FabISP, 190FAT16, 231FAT32, 231FileIO, 306firmware, 319float, 70for, 80fotodiodos, 205fotorresistencia, 204fototransistor, 205FQP30N06L, 244frecuencia, 228función, 68funciones, 82funciones matemáticas, 118fuses, 192, 193, 198

Ggas, 211gateway, 276Genuino, 16, 24Gershenfeld Neil, 14giroscopio, 221GND, 25GP2Y0A21YK0F, 216GPIO, 320

GPL, 212GPS, 223grove, 46gsm

begin, 284beginSMS, 284endSMS, 284

GSM, 282GSM.h, 284GSMLibrary, 283

HHall, 212header, 24hibernación, 176hidrógeno, 212HIGH, 96highByte, 121hitachi 44780, 148HMC5883L, 222hora, 225HTML, 278, 296HttpClient, 303humedad, 209humo, 212

II2C, 263

begin, 263beginTransmission, 263endTransmission, 264onReceive, 264write, 264

ICSP, 190IDE, 16, 319ideone, 66if, 76Igoe Tom, 15imán, 212impresoras 3D, 19impulsos, 117infrarojos, 213INPUT_PULLUP, 136, 203instalación, 48int, 68, 70

327

Índice analítico

interfaz bidireccional, 261interferencias, 255Internet de las Cosas, 286interrupción, 163, 173, 204

CHANGE, 164cli(), 175FALLING , 164HIGH , 164LOW , 164RISING, 164sei(), 175TIME_OVF_vect, 175

interrupciones, 166interrupt service routines, 165IoT, 286IR, 216isAlpha, 121isAlphaNumeric, 121isAscii, 121isControl, 121isDigit, 121isGraph, 121isHexadecimalDigit, 121isLowerCase, 121ISP programmer, 190isPrintable, 121isPunct, 121ISR, 165isSpace, 121isUpperCase, 121isWhitespace, 121

JJavaScript, 300JQuery, 301jumper, 45, 320

Kkeyboard.h, 185

Llámparas incandescentes, 239LCD03, 152LED, 52, 127

bandas , 239

LED RGB, 133lenguaje C, 59less, 294level shifter, 262librería, 158

añadir, 159archivo header, 160creación, 160instalación, 159library manager, 159

LiFi, 284Lilypad, 33Linux, 30, 285, 292liquidcrystal.h, 150LM35, 208log, 230long, 70loop, 48, 87LOW, 96lowByte, 121ls, 292luz, 204

Mmac, 270, 274mailbox, 304main, 68maker, 19map, 105, 119Martino Gianluca, 15master, 263max, 118MCP41, 249MCP 4725, 250MCU, 320MCUSR, 176Mellis David, 15memoria

EEPROM, 167, 320flash, 166, 169, 320RAM, 167, 320

MEMS, 221mensaje, 253mercurio, 213metano, 212

328


microcontrolador, 17, 23micrófono, 227micros, 113microSD, 231, 289microsegundos, 113MiDi, 284MIDI, 44MIFARE, 229millis, 112min, 118miso, 193MMA7371, 221módem, 283modo de reposo, 178modulación de la amplitud, 254modulación de la fase, 254modulación de la frecuencia, 254modulaciones, 254módulos, 156mosfet

logic level, 244MOSFET, 261mosi, 193motor, 239motor paso a paso, 246mouse.h, 188MQ, 211muestreo, 228 música, 113mv, 294

Nnanotecnologías, 221navegador, 278NFC, 228NMEA, 223noInterrupts, 166nop, 170NPN, 236números aleatorios, 120

Oohm, 311onda cuadrada, 104open source, 16

OpenWrt, 285OpenWrt-Yun, 288operadores, 73optoacoplador, 240optoaislador, 247ozono, 212

PParaimpu, 281parámetros, 83permisos de archivo, 293pgm_read_byte_near, 168pgmspace.h, 168piconet, 270ping, 290pinMode, 91PIR, 213planificador, 171PNA4602, 218PNA4602m, 216PNP, 236Pololu A4988, 246Port Mapping, 280potenciómetro, 201potenciómetro digital, 248pow, 119power.h, 178prescaler, 173, 176printf, 68println, 107procedimiento, 84process, 305Processing, 15, 48PROGMEM, 168programa, 66programación

condición, 65flujo, 64repetición, 65

proveedor IoT, 281puerto, 278puerto serie, 255pull down, 134pull up, 135, 264pulseIn, 117

329

Índice analítico

pulse-width modulation, 26pwd, 292pwm, 194PWM, 26, 103, 129, 142, 321

software, 131python, 302, 304

Rradiaciones infrarrojas, 206radianes, 120random, 120randomSeed, 120ratón, 184

MOUSE_LEFT, 188MOUSE_MIDDLE, 188MOUSE_RIGHT, 188

rc servo, 140rebotes, 137 receptor, 253 registro

DDR, 170de desplazamiento, 153PIN, 170pipo, 153piso, 153PORT, 170sipo, 153siso, 153

registro de desplazamiento, 152registros, 172relé, 238reloj, 198, 321reposo, 177reset, 177, 301resistencia variable, 201resistor, 311

bandas, 311códigos de color, 311lectura valor, 312símbolo, 314

REST, 288return, 84RFID, 228rm, 294robot, 20

router, 280router port mapping, 280RS232, 269RS485, 269RX, 255

Ssalida

digital, 194salida digital, 96Sanguino, 40scheduler.h, 171Schutte

Herman, 261sck, 193SCL, 263SDA, 263seeed studio, 46sensor analógico, 109sensor capacitivo, 214señal de audio, 227Serial, 255serie

asíncrona, 267available, 258begin(), 256print, 257println, 256read, 258síncrona, 267write, 257

Serial Monitor, 106, 256Serial Peripheral Interface, 26, 267Serial Plotter, 258servicios web, 277servidor web, 275, 278, 296servo.h, 143servomotor, 140, 198setup, 48, 87shield, 16, 321

data logger , 43e-Ink, 43ethernet, 42GPS, 43GSM, 43

330


LCD, 43MIDI, 44motor, 44MP3, 44pwm, 44wifi, 43ZigBee , 44

shift register, 152, 153SIM, 283símbolo, 254sin, 120sincronía, 321sizeof, 125, 258sketch, 48, 87Sketchbook, 160slave, 263sleep.h, 178smart card, 228SMS, 283Software Serial, 259SPI, 190, 267, 275, 281, 321

begin, 267CS, 267daisy-chain, 267end, 268MISO, 267MOSI, 267SCK, 267transfer, 267

SPI.h, 267sprintf, 257sqrt, 119SRF05, 219ssh, 291stdout, 67subnet mask, 276switch, 78System On Chip, 17

Ttags, 228tan, 120tarea, 171tarjeta SD, 231tarjetas SD, 230

TCNT, 174teclado, 184telefonía móvil, 282telnet, 296temperatura, 207tensión de referencia, 189terminal, 271termistor, 207termopar, 209then, 77tiempo, 224tiempo real, 289tilt sensor, 213timeout, 117timestamp, 111TIMSK, 173TinkerKit, 18, 45tinyGPS, 224TO35, 236TO220, 236tone, 113touch, 293transistor

bipolar, 235en corte, 237FET, 241J-FET, 241saturación, 237

transmisiones paralelas, 255transmisiones serie, 255transmisor, 253transpondedor, 228triac, 240trimmer, 201TTCR, 173TX, 255type casting, 73

UUART, 255, 321ultrasonidos, 219ultravioletas, 206unión PN, 241upload, 54USB, 24

331

Índice analítico

Vvariable, 70

persistente, 166volatile, 165

verify, 53vi, 293void, 68, 84, 88

Wwatchdog, 176, 178WDE, 177WDIE, 177WDTCSR, 176wdt.h, 177WDTON, 177wearable, 33, 270, 286web client, 277WEP, 282

while, 78WiFi, 281, 285WiFi Shield, 281winavr, 193Wire.h, 263wireless, 281Wiring, 15wiznet, 275WPA2, 282

Yyield, 172YunClient, 299YunServer, 299

ZZeptoJs, 301ZigBee, 44, 274

ARDUINO -...

Documents

Transcript of ARDUINO -...