Manual de Usuario Modulo 8

Módulo 8 ARDUINO: La tecnología al alcance de todos

open source

Con más de 80 ejemplos !!

INGENIERIA DE MICROSISTEMAS PROGRAMADOS S.L. C/ Alda. Mazarredo Nº 47 - 1º Dpto. 2 48009 BILBAO - BIZKAIA Tel/Fax: 94 4230651 email: [email protected] www.microcontroladores.com

ARDUINO: La tecnología al alcance de todos INDICE GENERAL www.microcontroladores.com

INDICE GENERAL TEMA1: El Universo ARDUINO 1.- INTRODUCCIÓN 2.- HERRAMIENTAS HARDWARE PARA ARDUINO 2-1 Tarjetas de control ARDUINO 2-2 Los Shields o tarjetas de aplicación 3.- HERRAMIENTAS SOFTWARE PARA ARDUINO 4.- EL EQUIPO DE PRÁCTICAS 4-1 El controlador Arduino NANO 4-2 El Laboratorio Universal Trainer 4-3 Instalación / Configuración del software

TEMA 2: Las entradas y salidas Digitales 1.- INTRODUCCIÓN 2.- ENTRADAS DIGITALES 3.- SALIDAS DIGITALES 4.- INSTRUCCIONES PARA EL CONTROL DE LAS E/S DIGITALES 4-1 Función: pinMode() 4-2 Función: digitalRead() 4-3 Función: digitalWrite() 5.- EL PRIMER EJEMPLO: “FUNCIÓN SI” 5-1 Montaje práctico 5-2 El programa “Función SI” 5-3 Grabación del programa 5-4 Comprobación 5-5 Trabajo personal 6.- PRINCIPALES FUNCIONES LÓGICAS 6-1 Función lógica NO 6-2 Función lógica Y 6-3 Función lógica O 7.- FUNCIONES LÓGICAS DERIVADAS 7-1 Función NO-Y 7-2 Función NO-O 7-3 Función Exclusiva-O 7-4 Función NO-Exclusiva-O 8.- LOS PUERTOS 8-1 Ejemplo: Leer_Puerto 8-2 Ejemplo: Calculadora_Binaria

TEMA 3: Temporizaciones, expresiones y sonido 1.- INTRODUCCIÓN

i-1


2.- FUNCIONES DE TEMPORIZACIÓN 2-1 Función: delayMicroseconds() 2-2 Función: delay() 3.-EJEMPLO: INTERMITENCIA 3-1 Trabajo personal 4.- MAS EJEMPLOS 4-1 Ejemplo: Faro 4-1-1 Trabajo personal 4-2 Ejemplo: Juego_de_luces 4-2-1 Trabajo personal 4-3 Ejemplo: Semáforo_V1 5.- EXPRESIONES 5-1 Constantes 5-2 Variables 5-2-1 Tipos de variables 5-3 Operaciones 6.- SONIDO; Ejemplo: Tonos V1 6-1 Funciones de sonido 6-1-1 Función: tone() 6-1-2 Función noTone() 6-2 Ejemplo: Tonos_V2 6-3 Ejemplo: Tonos_V3 6-4 Ejemplo: Tonos_V4 6-5 Ejemplo: Melodias 6-6 Ejemplo: Semáforo_V2

TEMA 4: Toma de decisiones y sentencias de control 1.- INTRODUCCIÓN 1-1 Operadores de comparación 1-2 Operadores booleanos 2.- FUNCIÓN: IF(….) 2-1 Ejemplo: Timbre 3.- FUNCIÓN: IF(….) ELSE 3-1 Ejemplo: Juego_de_luces_V2 3-2 Ejemplo: Semáforo_V3 4.- FUNCIÓN: FOR(….) 4-1 Operadores compuestos 4-2 Ejemplo: Faro_V2 4-3 Ejemplo: Semáforo_V4 4-4 Ejemplo: Ráfagas 5.- FUNCIÓN: WHILE() 5-1 Ejemplo: Timbre_V2 5-2 Ejemplo: Contador 5-3 Ejemplo: Contador_V2 6.- FUNCIÓN: SWITCH() / CASE 6-1 Ejemplo: Decodificador

i-2


6-1-1 Trabajo personal 6-2 Ejemplo: Juego_de_luces_V3 6-3 Ejemplo: Decodificado_ BCD_7_segmentos 6-3-1 Trabajo personal 6-4 Ejemplo: Década 6-4-1 Trabajo personal 6-5 Ejemplo: Dado_Electrónico 7.- OTRAS FUNCIONES DE CONTROL 7-1 Función: do…while() 7-2 Función: break 7-3 Función: return() 7-4 Función: goto

TEMA 5: Las señales PWM y el control de servos 1.- INTRODUCCIÓN 1-1 ¿Para qué sirven las señales PWM? 1-2 Función: analogWrite() 2.- USANDO LAS SEÑALES PWM 2-1 Ejemplo: PWM 2-2 Ejemplo: Efectos 2-3 Ejemplo: Luces_Aleatorias 2-4 Ejemplo: Regulación 3.- SERVOMOTORES 3-1 Conexión de servos 3-2 La librería servo.h 3-2-1 Función: #include 3-2-2 Función: attach() 3-2-3 Función: writeMicroseconds() 3-2-4 Función: write() 3-2-5 Función: read() 3-2-6 Función: attached() 3-2-7 Función: detach() 4.- USANDO LOS SERVOS 4-1 Ejemplo: Servo 4-2 Ejemplo: Servo_V2 4-3 Ejemplo: Servo_V3 4-4 Ejemplo: Servo_Control

TEMA 6: Las comunicaciones 1.- NTRODUCCIÓN 2.- LA COMUNICACIÓN SERIE 2-1 Tipos de comunicación serie 2-2 La comunicación serie tipo UART 3.- ESTABLECIENDO LA COMUNICACIÓN 3-1 Función: Serial.begin() 3-2 Función: Serial.end() 4.- TRANSMISIÓN DE DATOS 4-1 Función: Serial.print()

i-3


4-2 Función: Serial.println() 4-3 Ejemplos de transmisión 4-3-1 Ejemplo: Saludos 4-3-2 Ejemplo: Números 4-3-3 Ejemplo: Monitor_Remoto 5.- RECEPCIÓN DE DATOS 5-1 Función: Sertal.available() 5-2 Función: Serial.read() 5-3 Función: Serial.parseint() 5-4 Función: Seral.parsefloat() 5-5 Ejemplos de recepción 5-5-1 Ejemplo: Control_Remoto 5-5-2 Ejemplo: Calculadora 5-5-3 Ejemplo: Potencia_PWM 5-5-4 Ejemplo: Servo_Control_Remoto 6.- MÁS EJEMPLOS 6-1 Funciones matemáticas 6-1-1 Ejemplo: Min_Max 6-1-2 Ejemplo: Absoluto 6-1-3 Ejemplo: Potencia 6-1-4 Ejemplo: Raíz 6-1-5 Ejemplo: Trigonometría 6-2 Funciones avanzadas 6-2-1 Ejemplo: Tiempo_On 6-2-2 Ejemplo: Eiempo_On_V2 6-2-3 Ejemplo: Medir_Pulso 6-2-4 Ejemplo: Frecuencímetro 6-2-5 Ejemplop: Tiempo_:de_Activación 7.- MÁS FUNCIONES PARA LAS COMUNICACIONES 7-1 Función: Serial.find() 7-2 Función: Serial.findUntil() 7-3 Función: Serial.peek() 7-4 Función: Serial.readBytes() 7-5 Función: Serial.readBytesUntil() 7-6 Función: Serial.setTimeout() 7-7 Función: Serial.write() 7-8 Función: serialEvent()

TEMA 7: Las señales analógicas 1.- INTRODUCCIÓN 2.- CONVERSIÓN DIGITAL 3.- FUNCIONES DEL LENGUAJE ARDUINO 3-1 Función: analogReference() 3-2 Función: analogRead() 3-2 Función: map() 4.- PERIFÉRICOS ANALOGICOS 4-1 El potenciómetro 4-1-1 Ejemplo: Conversión_AD 4-1-2 Ejemplo: Umbrales 4-1-3 Ejemplo: Comparador_Analógico

i-4


4-1-4 Ejemplo: Control_de_Brillo 4-1-5 Ejemplo: Generador_BF 4-2 El sensor de luz 4-2-1 Ejemplo: Fotómetro 4-2-2 Ejemplo: Control_de_Alumbrado 4-2-3 Ejemplo: Regulación_de_Luz 4-3 El sensor de temperatura 4-3-1 Ejemplo: Temperatura 4-3-2 Ejemplo: Climatizador

TEMA 8: La pantalla LCD 1.- INTRODUCCIÓN 2.- LA PANTALLA LCD 3.- FUNCIONES PARA EL CONTROL DE UNA LCD 3-1 Función: LiquidCrystal() 3-2 Función: begin() 3-3 Función: setCursor() 3-4 Función: home() 3-5 Función: clear() 3-6 Función: write() 3-7 Función: print() 3-8 Función: cursor() 3-9 Función: noCursor() 3-10 Función: blink() 3-11 Función: noBlink() 3-12 Función: noDisplay() 3-13 Función: display() 3-14 Función: scrollDisplayLeft() 3-15 Función: scrollDisplayRight() 3-16 Función: leftToRight() 3-17 Función: rightToLeft() 3-18 Función: autoscroll() 3-19 Función: noAutoscroll() 3-20 Función: createChar() 4.- EJEMPLOS DE CONTROL DE UNA PANTALLA LCD 4-1 Ejemplo: HolaMundo 4-2 Ejemplo: Display 4-3 Ejemplo: Cursor 4-4 Ejemplo: Blink 4-5 Ejemplo: DirecciónTexto 4-6 Ejemplo: Scroll 4-7 Ejemplo: Autoscroll 4-8 Ejemplo: CaracteresPersonalizados 4-9 Ejemplo: SerialDisplay 5.- TRABAJO PERSONAL

i-5


RELACION DE MATERIALES La siguiente relación se corresponde con los materiales y accesorios necesarios para realizar todos los ejercicios y experimentos propuestos en el presente módulo 8. Se supone al lector en posesión del entrenador “UNIVERSAL TRAINER” en cualquiera de sus versiones V1, V2 o V3.              

Entrenador “UNIVERSAL TRAINER” (no incluído) Controlador Arduino NANO Cable USB tipo A a mini B Cable rígido de conexión de 0 Altavoz de 8Ω y 0.5 W Servo estándar Futaba FP-S3003 Pantalla LCD 16 x 2 Foto transistor BPW40 Sensor de temperatura LM35DZ Tira de pines macho / macho paso 2.54 Resistencia de carbón de 4K7, ¼ W Resistencia de carbón de 10K, ¼ W Resistencia de carbón de 100K, ¼ W CD-ROM con manual de usuario, documentación técnica, ejemplos y herramientas de programación

i-6


BIBLIOGRAFIA Y DIRECCIONES DE INTERÉS 

“ARDUINO:la tecnología al alcance de todos”. Editorial: Creaciones Copyright. Autor: Mikel Etxebarria Isuskiza. La obra se puede considerar como un complemento al contenido del presente módulo de prácticas. Propone una importante colección de ejemplos que se resuelven con materiales y componentes muy económicos.



www.microcontroladores.com Es la dirección de la página web de Ingeniería de Microsistemas Programados S.L. En ella puedes encontrar gran cantidad de productos relacionados con la electrónica y los micro controladores, así como abundante información técnica.



www.arduino.cc Es la página oficial de la organización de Arduino. En ella encontrarás todos los productos originales de Arduino, información técnica, descargas de las herramientas y manual de referencia del lenguaje de programación de Arduino.



www.arduino.cc/es Es la versión en caastellano de la página anterior. Es probable que no esté totalmente actualizada.

i-7


i-8

ARDUINO: La tecnología al alcance de todos TEMA 1: El Universo ARDUINO www.microcontroladores.com

TEMA 1: El Universo ARDUINO 1.- INTRODUCCIÓN Hasta no hace demasiado tiempo, el diseño y desarrollo de aplicaciones y proyectos basados en microcontroladores, estaba reservado a personal cualificado y con unos determinados conocimientos técnicos tanto en electrónica como en programación. Las herramientas necesarias para acometer esos proyectos se dividen en dos grandes grupos: 



Herramientas hardware. Consisten en diferentes tipos de tarjetas sobre las cuales se desarrolla y montan los circuitos electrónicos necesarios. Aquí también se incluyen los equipos e instrumentos que ayudan a poner a punto nuestros programas: emuladores, depuradores, grabadores, instrumentos de medida, etc… Herramientas software. Es un conjunto de aplicaciones que facilitan el desarrollo de nuestros programas. Es decir, se tratan de programas que nos ayudan a programar. Podemos citar a los editores de texto que emplearemos para escribir un programa, los simuladores, los intérpretes y los compiladores del lenguaje de programación que estemos empleando.

Todas ellas tienen un coste bastante elevado que no está al alcance de todos. Únicamente las Escuelas de formación profesional, Ingenierías, Universidades, así como empresas de diseño, montaje, investigación y desarrollo (I+D) o similares, se lo pueden permitir. Afortunadamente a día de hoy esto ya no tiene porqué ser así necesariamente. Gracias a plataformas como ARDUINO es posible acercar el mundo de la tecnología a todas las personas, empezando por estudiantes de Enseñanza Secundaria Obligatoria (ESO), bachiller, y módulos profesionales, como a todo tipo de aficionados a la misma. ARDUINO es una palabra de origen Germánico que se podría traducir como “El que ayuda a los amigos”. Allá por el año 2005, en el instituto Italiano de Diseño Interactivo (IVRA), se reúne un equipo de profesores y alumnos, procedentes de diferentes disciplinas, y liderados por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis y Nicholas Zambetti. Apuestan por desarrollar una tarjeta electrónica sencilla y de muy bajo precio, que pueda ser utilizada en cualquier tipo de proyecto y en cualquiera de las diferentes disciplinas y áreas del conocimiento. Que tenga un lenguaje de programación sencillo y fácil de aprender y, sobre todo, ¡accesible y abierta a todo el mundo!. Esto es ARDUINO. Este módulo que tienes entre manos pretende acercarte a la tecnología. Para ello, en Ingeniería de Microsistemas Programados (MSE), hemos diseñado un buen número de ejemplos de programación que trataremos de presentar de forma ordenada y progresiva. Se trata de que tú, querido lector, puedas aprender a utilizar la plataforma ARDUINO y su programación de una forma amena y eminentemente práctica. Lo hemos dividido en una serie de temas que te van a permitir estudiar, analizar y utilizar los múltiples recursos internos de que consta un controlador como ARDUINO. Al mismo tiempo, vas aprendiendo las sentencias y funciones más importantes de que consta su lenguaje de programación. Ten en cuenta que todo lo que aprendas sobre los recursos internos y el lenguaje de programación (muy similar al lenguaje C), lo podrás utilizar en un futuro no muy lejano sobre controladores más potentes como los utilizados en aplicaciones comerciales e industriales. 2.- HERRAMIENTAS HARDWARE PARA ARDUINO ARDUINO es básicamente una tarjeta electrónica. Con el paso del tiempo se han desarrollado diferentes modelos que se diferencian en su aspecto y prestaciones. Aunque el lenguaje de programación es similar para todas ellas, cada uno elige la que mejor se adapte a sus necesidades. En cualquier caso recordemos que todas ellas son abiertas, por lo que se pueden obtener sus esquemas y toda la información

1-1


técnica disponible sobre las mismas. Vamos a echar un vistazo a las más representativas y a sus características más relevantes.

2.1 Tarjetas de control ARDUINO La figura 1-1 muestra la tarjeta ARDUINO UNO. Probablemente es la más utilizada y desciende directamente de la mítica ARDUINO DIECIMILA, que apareció allá por el año 2005. Es una tarjeta muy sencilla, económica y fácil de conseguir. A través de un puerto USB se conecta con el PC, desde donde se realiza la grabación de los programas de aplicación. Mediante unos sencillos conectores se accede a las diferentes líneas de E/S del controlador. Con unos cables podemos conectar con los periféricos que deseemos gobernar: sensores, interruptores, leds, displays y un largo etcétera. Figura 1-1. La tarjeta ARDUINO UNO

Por otra parte, en la fotografía de la figura 1-2, tenemos la tarjeta de control ARDUINO MEGA2560. Se puede considerar como la hermana mayor. Salta a la vista su mayor tamaño ya que dispone de un elevado número de líneas de E/S, lo que permite controlar un gran número de periféricos. De la mitad a la derecha aproximadamente se puede apreciar la extensión de los conectores de E/S, respecto a los de la tarjeta ARDUINO UNO. Figura 1-2. La tarjeta ARDUINO MEGA 2560 En la figura 1-3 tenemos otro modelo de tarjeta de control, la ARDUINO NANO. Se trata de una versión miniaturizada y mejorada de la tarjeta ARDUINO UNO. Viene encapsulada en un formato DIL de 0.6” con 30 pines distribuidos en dos filas de 15 pines, y unas dimensiones de tan solo 0.73” x 1.70” (18.5 mm x 43.1). Este modelo se puede insertar directamente sobre un zócalo, una tarjeta impresa o un módulo board para el montaje sin soldadura, y conectar con los periféricos que vamos a gobernar en la aplicación. ¡¡ ES LA QUE VAMOS A EMPLEAR EN EL PRESENTE MÓDULO DE PRÁCTICAS !! Figura 1-3. La tarjeta de control ARDUINO NANO Aunque hemos mostrado las tres tarjetas de control más utilizadas, al menos hoy en día, basta con que visites la página oficial de ARDUINO (www.arduino.cc), para que veas la variedad de tarjetas ARDUINO existentes. Además de por su aspecto, las tarjetas se diferencian en sus prestaciones y características. En la siguiente tabla se hace una breve comparación de las características más relevantes de los tres modelos de tarjetas de control de ARDUINO que acabamos de presentar.

1-2


CONCEPTO Tipo de Controlador Tensión de alimentación Alimentación interna de trabajo Velocidad Patillas de E/S digital Entradas analógicas Corriente en cada patilla de E/S Salidas PWM Memoria FLASH de programa Ocupado por el bootloader Memoria RAM de datos Memoria EEPROM de datos

UNO ATmega328 7-12V 5V 16MHz 14 6 40mA 6 32KB 0.5KB 2KB 1KB

MEGA 2560 ATmega2560 7-12VC 5V 16MHz 54 16 40mA 15 256KB 8KB 8KB 4KB

NANO ATmega328 7-12V 5V 16MHz 14 8 40mA 6 32KB 2KB 2K 1KB

2-2 Los Shields o tarjetas de aplicación Como ocurre con cualquier otro sistema, las diferentes tarjetas de control de ARDUINO no sirven de gran cosa si no les conectamos los periféricos que vamos a gobernar: sensores, interruptores, indicadores, altavoces, motores, displays, pantallas, relés, válvulas y un sinfín de dispositivos diferentes. Algunos periféricos son de uso tan común y tan extendido, que muchas empresas fabrican las tarjetas que los contienen. Reciben el nombre de “Shields”, y se pueden conectar o “pinchar” directamente sobre las tarjetas de control ARDUINO UNO, MEGA 2560, o cualquiera que sea compatible. En la figura 1-4 se muestra el shield ARDUINO BASIC I/O. Está desarrollado, fabricado y comercializado por Ingeniería de Microsistemas Programados. Se trata de un circuito puramente didáctico. Contiene unos periféricos muy básicos y sencillos: leds, pulsadores, altavoz, potenciómetros, y sensores de luz, de infra rojos y de temperatura. La idea es que se puedan conectar directamente con las líneas de E/S de las tarjetas de control ARDUINO UNO o MEGA 2560. Basta con insertar esta tarjeta sobre la de control. El alumno se centra en la programación y se olvida de realizar conexiones eléctricas. Los periféricos ya están conectados. Figura 1-4. El Shield ARDUINO BASIC I/O La fotografía de la figura 1-5 muestra un ejemplo de aplicación. El Shield BASIC I/O está insertado sobre la tarjeta de control ARDUINO UNO. Esta contiene un programa que controla el encendido de un led a partir de un pulsador. Debemos saber que, si mediante un programa somos capaces de leer el estado de una entrada (p.e. un pulsador), también seremos capaces de lee un sensor, un final de carrera, un detector, etc.. Igualmente, si somos capaces de controlar el encendido de un led, también podremos actuar sobre un motor, un relé, una válvula, una señal acústica de alarma, etc… En resumidas cuentas, mediante el Shield BASIC I/O tenemos una forma muy económica y sencilla de probar nuestros programas y simular situaciones reales. Figura 1-5. Ejemplo de aplicación

1-3


Aunque no se trata de un Shield propiamente dicho, otra forma de conectar periféricos a nuestra tarjeta de control ARDUINO para probar los programas, es mediante el uso de entrenadores de electrónica de propósito general, como puede ser el de la figura 1-6. Se trata de nuestro Universal Trainer V3. Contiene una serie de valiosos periféricos tales como leds, interruptores, displays, etc… y, lo que es más importante, una amplia zona para el montaje sin soldadura de cualquier circuito electrónico. También dispone de tensiones de alimentación, generador de funciones y mucho más. ¡¡ Es el equipo que vamos a usar en los ejemplos que proponemos en el presente módulo de prácticas !!

NOTA: Los ejemplos propuestos también se pueden realizar por todos aquellos usuarios que dispongan de las versiones anteriores, la V1 y la V2, del entrenador Universal Trainer.

Figura 1-6. El entrenador Universal Trainer V3 Como ya se ha comentado anteriormente, dada su popularidad y su uso extendido, podemos encontrar numerosos shields de propósito específico como los mostrados en la figura 1-7. De entre los muchos disponibles en el mercado, cabe destacar los shields para el control de relés y de motores, shields con interfaces a Ethernet, WiFi, y Bluetooth, shileds para el control de pantallas gráficas y de texto, robots y muchos más. Incluso podemos encontrar shields universales para la construcción de prototipos. Consisten en unas tarjetas impresas que se insertan sobre las tarjetas ARDUINO de control y donde cada cual puede cablear la electrónica que necesite en un momento dado. Figura 1-7. Shields de propósito general

3- HERRAMIENTAS SOFTWARE PARA ARDUINO ARDUINO es un controlador al que debemos programar para que realice una determinada tarea. Para ello necesitamos una serie de herramientas software que nos permitan y faciliten la programación. Una de esas herramientas es el propio lenguaje que vamos a emplear en el diseño de nuestros programas. Recibe el nombre de “Lenguaje ARDUINO” y se trata de un lenguaje expresamente diseñado para poder ser usado por personas que no tengan grandes conocimientos de programación. Recordemos que ARDUINO pretende ser una plataforma que acerque la tecnología a todos los niveles y que nos aliente y nos siembre el “gusanillo” de la programación. Es un lenguaje de alto nivel similar en funciones y estructuras al lenguaje C, muy utilizado en el ámbito profesional. ¡¡ Todo lo que aquí aprendas, lo podrás usar en un futuro !! El lenguaje ARDUINO, como todos los lenguajes (incluidos los humanos), está en constante evolución. Con el tiempo van apareciendo nuevas expresiones, reglas y sentencias. En este módulo de prácticas vamos a construir nuestros programas y ejemplos usando las funciones principales. Ya tendrás tiempo de ir profundizando conforme vayas adquiriendo más conocimientos. No olvides que el lenguaje de programación ARDUINO ¡¡ es libre !!.

1-4


Otra herramienta software que necesitamos es la conocida como “Entorno de trabajo de ARDUINO” también conocido como “IDE”. Es una aplicación que se ejecuta en nuestro PC y la podemos conseguir, de forma gratuita, para los sistemas operativos Windows, Mac OS X y Linux. Con ella podemos escribir nuestros programas, verificarlos, guardarlos en un archivo, recuperarlos y grabarlos físicamente sobre la memoria FLASH de programa del controlador ARDUINO. La figura 1-8 muestra el aspecto del IDE de ARDUINO.

Figura 1-8. El entorno de trabajo IDE de ARDUINO Vemos una ventana sobre la cual escribiremos nuestro programa empleando el lenguaje ARDUINO. En el argot de ARDUINO los programas reciben el nombre de “Sketch”. Mediante una serie de opciones y botones podremos:    

Escribir y editar nuestro programa. Guardar en un archivo nuestro programa. Recuperar nuestro programa o Sketch desde un archivo. Verificar que nuestro programa esté escrito correctamente según las reglas del lenguaje ARDUINO. Esto implica que el IDE de ARDUINO … ¡¡ Incluye al propio lenguaje ARDUINO !!

1-5


    

Grabar el programa o Sketch en la memoria de programa tipo FLASH del controlador. Establecer preferencias de trabajo. Seleccionar el tipo de tarjeta con la que estamos trabajando: ARDUINO UNO, MEGA 2560, NANO, etc. Seleccionar el canal de comunicaciones entre el ordenador y la tarjeta ARDUINO. Y mucho más….

Una vez más tenemos que repetir que el entorno IDE de trabajo de ARDUINO, y el lenguaje de programación que incluye, son totalmente gratuitos y están disponibles en la página web oficial: www.arduino.cc. Te lo puedes descargar libremente para los sistemas operativos Windows, Mac OS X y Linux. Es más, recomendamos que periódicamente visites el sitio con objeto de descargar la última versión disponible. 4.- EL EQUIPO DE PRÁCTICAS Vamos a ir describiendo el equipo que necesitamos para poder realizar los múltiples ejemplos de programación que vamos a proponer en el presente módulo de prácticas. 4.1 El controlador ARDUINO NANO Es el que vamos a utilizar en todos los ejemplos. En la figura 1-9 tenemos la distribución de las patillas de la tarjeta de control ARDUINO NANO. Te recomendamos que la tengas siempre a mano. Observa que todas ellas tienen una, dos e incluso tres funciones diferentes que se pueden configurar por programa. Por ejemplo, la patilla 9 se puede emplear como línea digital de entrada o salida (E/S) o bien como salida de señal PWM. Tal y como se aprecia en la imagen, la patilla 1 es la primera del ángulo superior izquierdo. Se van contando de forma correlativa en sentido contrario a las agujas del reloj.

Figura 1-9. Patillaje del ARDUINO NANO En la tabla siguiente se detalla la función de cada una de ellas.

1-6


FUNCION D0 – D13

DESCRIPCIÓN Entradas o salidas digitales. Permiten leer o sacar niveles lógicos: “1” = tensión (5V); “0” = No tensión (0V)l La línea 13 está conectada a un led situado en la propia tarjeta. TX/RX Señales de transmisión (TX) y recepción (RX) en las comunicaciones serie tipo USART. RESET Entradas para reiniciar el sistema. Es activa por nivel “0” y están también conectadas con el pulsador que hay en la propia tarjeta. GND Entradas de tierra de alimentación INT0 / INT1 Entradas de interrupción externa. Se pueden configurar por programa para que sean activas por nivel “0”, o por flanco ascendente o descendente o por cambio de estado lógico. PWM Salidas de señal modulada en anchura (PWM) SDA / SCL Señales para la comunicación serie tipo I2C. Esta comunicación se gestiona mediante las funciones incluidas en la librería “Wire” SS / MOSI Señales para la comunicación serie tipo SPI. Esta comunicación se gestiona MISO / SCK mediante las funciones incluidas en la librería “SPI” AREF Entrada de tensión de referencia para los convertidores analógico / digital A0 – A7 Entradas analógicas al convertidor. Este tiene una resolución de 10 bits por lo que proporciona una escala de 1024 valores diferentes. 3V3 Salida de 3.3V. +5V Entrada / Salida de la tensión interna de trabajo, estabilizada a 5V VIN Entrada de tensión de alimentación. Puede estar comprendida entre 6 y 20V como máximo. U1

Simplemente representamos el número de cada una de las patillas y la función principal de las mismas: D0 - D13 (E/S digitales), A0 – A7 (entradas analógicas), RESET, GND, 3V3, AREF, +5V y VIN. Hay que remitirse a la figura 1-9 anterior para conocer el resto de funciones que pueden estar asociadas a alguna de esas patillas.

D1 D0 RESET GND D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12

VIN GND RESET +5V A7 A6 A5 A4 A3 A2 A1 A0 AREF 3V3 D13

ARDUINO NANO

En lo sucesivo, con el fin de simplificar los esquemas eléctricos de los ejemplos propuestos, el símbolo de la tarjeta ARDUINO NANO lo vamos a representar como se muestra en la figura 1-10.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Figura 1-10. Símbolo eléctrico de ARDUINO NANO

4.2 El Laboratorio Universal Trainer V3 Lo presentamos en la figura 1-6 anterior. Se trata de un laboratorio de propósito general para trabajar el aspecto práctico de la electrónica en sus diferentes especialidades: semiconductores, digital, analógica, micro programable, etc… Nos aprovecharemos de los recursos que dispone para trabajar con nuestro ARDUINO NANO:      

Entradas y salidas digitales mediante interruptores y leds. Displays de 7 segmentos. Entradas analógicas. Zumbador Fuentes de alimentación con diferentes tensiones de salida. Generador lógico con señales de onda cuadrada de diferentes frecuencias.

1-7


Además, dispone de una amplia zona para el montaje sin soldadura. Esto nos permite insertar la tarjeta de control ARDUINO NANO, así como montar todos los circuitos eléctricos que necesitemos para llevar a cabo todo tipo de pruebas y experimentos.

D1 VIN D0 GND RESET RESET GND +5V D2 A7 D3 A6 D4 A5 D5 A4 D6 A3 D7 A2 D8 A1 D9 A0 D10 AREF D11 3V3 D12 D13

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

En primer lugar vamos a montar el circuito del esquema de la figura 1-11. Simplemente consiste en insertar ARDUINO NANO sobre el módulo board del entrenador, y alimentarlo con la tensión de +5V que éste nos proporciona. El montaje es común a todos los que iremos haciendo en las sucesivas prácticas. Aunque tenemos dos patillas, la 4 y la 29, por las que podemos aplicar la señal GND de alimentación, basta con que usemos una de ellas. En este caso empleamos la patilla 4. La patilla 27 la conectamos con la tensión de alimentación +5Vcc. Tanto GND como +5Vcc nos la suministra el entrenador Universal Trainer V3 Figura 1-11. Alimentando a ARDUINO NANO

En la fotografía de la figura 1-12 podemos apreciar el montaje práctico sobre el entrenador.

Figura 1-12. Montaje de ARDUINO NANO sobre el Universal Trainer V3 La tarjeta de control ARDUINO NANO se inserta a la derecha del módulo board del entrenador. De esta forma se hace más fácil su conexión con el PC, a través del conector mini USB. También disponemos de una amplia zona para el montaje de los circuitos y accesorios que precisemos en las diferentes prácticas. Como se muestra en la figura, empleamos tres cables para la alimentación de +5Vcc (rojos), y otros tres para la alimentación GND (negros). Ambas alimentaciones las suministra el entrenador Universat Trainer V3. Al conectar el entrenador se ilumina un led azul que indica la correcta alimentación de la NANO. También es posible que el led rojo, conectado con D13, parpadee. Esto es porque la NANO suele venir con un programa de test. IMPORTANTE: Aunque en este documento, todos los ejemplos se desarrollan sobre el entrenador Universal Trainer V3, también es posible hacerlo sobre las versiones anteriores, la V1 y la V2, de dicho entrenador.

1-8


4.3 Instalación / Configuración del software En el momento de escribir este documento, la última versión disponible de las herramientas software de Arduino, el entorno IDE de trabajo y el lenguaje de programación, es la 1.0.5. Se puede descargar de forma gratuita desde:

www.arduino.cc/en/Main/Software Recomendamos visitar este sitio con cierta frecuencia para obtener la última versión más actualizada. Al seleccionar la versión Arduino 1.0.5 (o la que sea), tenemos la opción de elegir para qué sistema operativo la deseamos: Windows, Mac OS X y Linux. En nuestro caso vamos a trabajar con Windows. Aunque todos los ejemplos los hemos realizado bajo W XP, también los hemos probado bajo W 7 y W8 de 64 bits. Funciona todo correctamente. En la versión 1.0.5 se puede descargar un único archivo ejecutable de instalación llamado “arduino1.0.5-windows.exe” y que también lo adjuntamos en el CDROM que acompaña a este módulo de prácticas. Al ejecutarlo, automáticamente se instala el entorno de trabajo (IDE), el lenguaje, los archivos auxiliares y los drivers. Basta con ir aceptando las diferentes preguntas que se realizan durante el proceso de instalación. En el escritorio aparecerá un icono de acceso directo. Al hacer doble click sobre él, se abre la ventana de trabajo de Arduino, como la mostrada en la figura 1-13.

Figura 1-13. El entorno IDE de trabajo de Arduino

1-9


Se trata de un entorno muy sencillo. La mayor parte de tareas las podemos realizar mediante los botones: verificar, grabar, nuevo, cargar y salvar Sketchs. El área destinada a la escritura de los programas o sketchs se comporta como un editor de textos convencional. Las opciones del menú principal permiten realizar las típicas operaciones de Windows relacionadas con los Archivos (“Archivo”), Edición de textos (“Editar”), Programas (“Sketch”), Selección de herramientas y configuración (“Herramientas”) y opciones de ayuda (“Ayuda”). Una de las primeras tareas a realizar es seleccionar con qué tipo de tarjeta de control vamos a trabajar. En nuestra caso, como se muestra en la figura 1-14, seleccionamos: Herramientas  Tarjeta  Arduino Nano w/ Atmega328

Figura 1-14. Selección de la tarjeta de control Arduino NANO Ahora podemos conectar la tarjeta Arduino NANO en uno de los puertos USB de nuestro PC. En pantalla nos aparece un “globo” indicando que se ha detectado un nuevo dispositivo USB, concretamente el ARDUINO NANO. Transcurrido un cierto tiempo el sistema nos informa de que el dispositivo está instalado y listo para usarse.

1 - 10


Cuando se conecta la tarjeta NANO y se instala sobre un puerto USB, se crea un canal serie virtual COMx. El siguiente paso es establecer la comunicación entre el entorno de trabajo IDE y dicho canal serie COMx. Para ello seleccionamos: Herramientas  Puerto Serial  COMx, como se muestra en la figura 1-15.

Figura 1-15. Selección del canal serie COMx de comunicaciones Es posible que en nuestro PC tengamos más de un canal serie COM. Si deseamos conocer en cuál de ellos quedó instalado nuestra tarjeta controladora Arduina NANO cuando la conectamos al puerto USB, podemos recurrir al administrador de dispositivos de Windows: InicioPanel de controlSistemaHardwareAdministrador de dispositivosPuertos (COM & LPT) Como se muestra en la figura 1-16, el puerto serie virtual se asignó, en nuestro caso, al COM23.

Figura 1-16. Asignación del puerto COM

1 - 11


¡Por fin! ya tenemos todo lo necesario para empezar a trabajar. Podemos hacer un pequeño programa, a modo de test, para comprobar el correcto funcionamiento de todo el sistema. Puede servir como ejemplo el que se muestra en la figura 1-17 que, como todos los demás ejemplos, se incluye en el CDROM que acompaña al módulo de prácticas.

Figura 1-17. Programa de test Aunque el programa del ejemplo es muy sencillo, no te preocupes si no consigues entenderlo en su totalidad. Simplemente lo transfieres, mediante el botón “Cargar”, a la tarjeta de control Arduino NANO. Observa que el led rojo se enciende y apaga a intervalos de un segundo. Puedes hacer también la siguiente comprobación. Desconecta el cable USB de la tarjeta Arduino NANO. Desconecta la alimentación del entrenador y la vuelves a conectar. El led sigue realizando la secuencia de intermitencia. Esto demuestra que, una vez has transferido un programa a la tarjeta, este permanece en ella indefinidamente, Arduino NANO es independiente del PC. Ya estás listo para empezar a realizar los múltiples ejemplos que vamos a ir proponiendo. En Ingeniería de Microsistemas creemos que te vas a divertir, al mismo tiempo que te vas introduciendo en la tecnología y la programación. Esperamos que te “enganches”.

1 - 12

ARDUINO: La tecnología al alcance de todos TEMA 2: Las entradas y salidas Digitales www.microcontroladores.com

TEMA 2: Las entradas y salidas Digitales 1.- INTRODUCCIÓN En el mundo digital todas las cosas u objetos se contemplan como si únicamente pudieran tener dos estados diferentes y opuestos. A esto se le conoce como estados “binarios”. Por ejemplo, una bombilla puede estar encendida o apagada, pero nunca se pueden dar ambas situaciones al mismo tiempo. Ejemplos como este podemos poner muchos:       

Un interruptor o un pulsador puede estar accionado o no, pero no ambas cosas al mismo tiempo El motor está girando (no importa a qué velocidad) o puede estar parado. La sirena de una alarma está activada o no lo está. Un relé puede estar activado o no, lo mismo que por ejemplo, una electro válvula. Podemos tener pulsada una tecla del teclado de nuestro ordenador, o no tenerla. Un sensor detecta la presencia de un objeto o su ausencia. Tu mismo, puedes reír o llorar, vivir o morir, pero nunca ambas cosas al mismo tiempo.

El concepto de “todo” o “nada”, “activado” o “desactivado”, “cerrado” o “abierto”, “pulsado” o “no pulsado”, tiene una relación directa con la electricidad. Efectivamente, la bombilla está “activada” cuando se le aplica tensión (+V), y “desactivada” cuando no se le aplica tensión (0V). Cuando un interruptor está “abierto” decimos que corta la tensión (0V), sin embargo cuando está “cerrado”, deja pasar la tensión (+V). Al objeto de abreviar se definen dos estados o niveles lógicos diferentes:  

“nivel 1” cuando hay tensión (+V). También se le denomina “nivel alto”, “high”, “ON” o, simplemente, “1” “nivel “0” cuando no hay tensión (0V). También se le denomina “nivel bajo”, “low”, “OFF” o, simplemente, “0”

Quizá a partir de este momento entiendas un poquito más el funcionamiento del programa de Test que viste en el tema anterior. Al led conectado en la patilla D13 de E/S se le aplicaba un nivel alto (HIGH) y se iluminaba. Luego se le aplicaba nivel bajo (LOW) y se apagaba. El proceso se repetía de forma indefinida con un intervalo de tiempo de 1 segundo para cada caso. En la figura 2-1 tenemos una representación gráfica de una señal digital o binaria. El eje vertical representa la tensión (+V). No importa su valor, aunque en los equipos digitales actuales es frecuente que sea de 5V o de 3.3V. Un “0” equivale a 0V y un nivel “1” equivale a tensión y se representa mediante una línea horizontal por encima de la línea que representa el nivel “0”. A esta gráfica se le llama “Diagrama de tiempos” Figura 2-1. Representación de una señal digital El eje horizontal representa el tiempo T. Muestra el intervalo de tiempo en que la señal digital permanece a “0”, luego a “1” y vuelta a valer “0”. Ahora fíjate en el diagrama de tiempos de la figura 2-2. Representa a tres señales digitales de otros tantos dispositivos: un interruptor, un motor y una bombilla. Observándolo con atención podemos decir que:   

El interruptor está abierto (sin accionar) durante un segundo. Luego se cierra (acciona) durante otro segundo. Se abre durante tres segundos y, finalmente, se cierra durante dos. El motor está parado durante dos segundos, en movimiento durante cuatro y parado durante uno. La bombilla se apaga y enciende a intervalos de un segundo. ¿Te suena?

2-1


Figura 1-2. Análisis de tres señales digitales

2.- ENTRADAS DIGITALES Son señales binarias que se introducen al controlador (p.e. a la tarjeta Arduino NANO) a través de determinadas patillas, y procedentes de determinados periféricos de entrada como pueden ser interruptores, pulsadores, sensores, detectores, teclados, etc…Sea cual sea el periférico empleado, solo puede introducir señales con niveles lógicos binarios: “0” (no tensión) o “1” (tensión). Los pulsadores y/o interruptores son los periféricos de entrada más utilizados y sencillos que existen. En la figura 2-3 se muestra un posible esquema eléctrico de conexión entre un pulsador y una línea de entrada del controlador. Cuando el pulsador está sin accionar, la señal S suministra un nivel lógico “0” (0V) a la entrada del controlador. Cuando se pulsa introduce un nivel lógico “1” (+5V). Se dice de este circuito que trabaja con “lógica positiva”. Si NO se acciona se introduce un nivel “0”, y si se acciona se introduce un nivel “1” al controlador.

Figura 2-3. Pulsador de entrada con lógica positiva

Otra forma de circuito es la mostrada en la figura 2-4. Cuando el pulsador está sin accionar, la señal S suministra un nivel lógico “1” de +5V a la entrada del controlador. Cuando se pulsa introduce un nivel lógico “0”.Se dice que este nuevo circuito trabaja con “lógica negativa” o “invertida”. Si NO se acciona introduce un nivel “1”, si se acciona introduce un nivel “0” al controlador. Funciona justamente al revés que el anterior.

Figura 2-4. Pulsador de entrada con lógica negativa

2-2


No importa cuál de los dos circuitos empleemos. Lo realmente importante es saber cómo leer la entrada del controlador a la que está conectado ese pulsador, e interpretar correctamente el valor binario leído. 3.- SALIDAS DIGITALES Son señales binarias de nivel “0” (no tensión) o de nivel “1” (tensión) que, es esta ocasión, proporciona el controlador por algunas de sus patillas. En esas patillas conectamos los periféricos de salida que vamos a gobernar tales como: bombillas, relés, motores, válvulas, alarmas, etc.. El controlador puede por tanto activarlos o desactivarlos. Uno de los periféricos de salida más sencillos y económicos son los llamados diodos “Led”. Son pequeños dispositivos que cuando se activan emiten luz. El led tiene dos patillas: ánodo (A) y cátodo (K). Para que se ilumine es necesario aplicarles una tensión de “polarización directa”. Se consigue cuando el ánodo (A) es positivo respecto al cátodo (K). Los hay de diferentes formas, tamaños y colores y se emplean mucho como pilotos de señalización o indicadores. En la figura 2-5 se muestra el esquema eléctrico necesario para conectar una patilla de salida del controlador, a uno de estos leds. Cuando la señal S de salida está a nivel “0” (0V), el diodo led se apaga. Su ánodo queda con 0V, al igual que el cátodo. Cuando la señal de S salida está a nivel “1” (+5V), el led se ilumina. Su ánodo ahora es positivo respecto al cátodo. Se dice de este circuito que trabaja con “lógica positiva”. Si el controlador saca un “0” el led se apaga, si saca un “1” el led se enciende. Figura 2-5. Control de un led de salida con lógica positiva

Otra forma de controlar a un led es mediante el circuito de la figura 2-6. Cuando la señal S que saca el controlador por una de sus patillas de salida es de nivel “1” (+5V), el led se apaga ya que tanto el ánodo como el cátodo tienen la misma tensión (+5V). Cuando la señal S de salida está a nivel “0” (0V), el led se ilumina. En esta ocasión el ánodo es positivo (+5V) respecto al cátodo. Este circuito trabaja con “lógica negativa” o “invertida”. Si el controlador saca un “0” el led se enciende, si saca un “1” el led se apaga. Funciona justo al contrario que el circuito anterior.

Figura 2-6. Control de un led de salida con lógica negativa

Nuevamente no es importante cuál de los dos circuitos empleemos. Lo que realmente importa es saber qué hay que hacer para que el controlador saque por sus patillas de salida, cualquiera de los dos niveles lógicos. RECORDAR: Lo mismo que leemos el estado de un pulsador, podemos leer el estado de una tecla, un interruptor, un sensor, un final de carrera, etc… Igualmente, si que somos capaces de activar o desactivar un led, podremos activar o desactivar un relé, un motor, una válvula, etc.. IMPORTANTE. La corriente que es capaz de entregar un controlador por cualquiera de sus patillas de salida, es limitada. En el caso de Arduino NANO es una corriente de 40mA, suficiente para activar directamente leds o cargas de consumo similar. Si se quiere controlar dispositivos con un mayor consumo, las líneas de salida deben conectarse a circuitos que amplifiquen en corriente y/o en tensión la señal. De no hacerlo es muy posible que estropeemos el controlador.

2-3


4.- INSTRUCCIONES PARA EL CONTROL DE LA E/S DIGITALES Ya va siendo hora de que estudiemos las funciones del lenguaje Arduino encargadas de controlar las líneas de entrada o salida (E/S) de nuestra tarjeta Arduino NANO. Fundamentalmente son tres y muy sencillas: 4-1 Función pinMode() Configura una línea digital (patillas D0 - D13) para que actúe como entrada o como salida. Normalmente se suele poner al principio de un programa. Por defecto, al iniciar el sistema, todas las líneas de E/S quedan configuradas como entradas. Sintaxis: pinMode(pin,modo) pin: Expresa el número de la patilla de E/S que vamos a configurar (D0-D13) modo: Establece si actúa como entrada (INPUT) o salida (OUTPUT) Ejemplos: pinMode(6,OUTPUT); pinMode(13,OUTPUT); pinMode(3,INPUT);

//La línea D6 se configura como salida digital //La línea D13 se configura como salida digital //La línea D3 se configura como entrada. Es opcional

4-2 Función digitalRead() Lee y devuelve el estado (“1” o “0”, “HIGH” o “LOW”) de cualquiera de las patillas digitales. Sintaxis: digitalRead(pin) pin:

Expresa el número de la patilla que vamos leer (D0-D13)

Ejemplos; V=digitalRead(6); V=digitalRead(3);

//Lee el estado actual de la patilla digital D6 y lo guarda en la variable V. //Lee el estado actual de la patilla digital D3 y lo guarda en la variable V.

4-3 Función digitalWrite() Escribe o saca por una patilla digital de salida el valor binario “1” o “0”, “HIGH” o “LOW”. Sintaxis: digitalWrite(pin,valor) pin: valor:

Expresa el número de la patilla de salida sobre la que vamos a escribir. Indica el valor de salida: “HIGH” =”1”, o bien “LOW” = “0”.

Ejemplos digitalWrite(6,HIGH); digitalWrite(13,LOW); digitalWrite(6,digitalRead(3));

//La salida D6 se pone a nivel “1” (+5V) //La salida D13 se pone a nivel “0” (0V) //Lee el valor de la entrada D3 y lo saca por la salida D6

2-4


5.- EL PRIMER EJEMPLO: “FUNCION SI” ¡Manos a la obra! Vamos a resolver íntegramente nuestro primer proyecto al que llamaremos “Función SI”. Será una cosa muy sencilla pero que nos permitirá utilizar las tres funciones anteriores y observar el aspecto general de un programa escrito en el lenguaje Arduino.

5-1 Montaje práctico

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc


Se trata de leer el estado lógico de un interruptor conectado con la entrada D3, y reflejarlo sobre un led conectado con la salida D2. SI el interruptor vale “1”, el led también valdrá “1”. SI el interruptor vale “0”, el led también valdrá “0”. Fíjate en el esquema eléctrico de conexiones de la figura 2-7.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Vamos a usar el entrenador Universal Trainer V3 (o el V1 / V2) que, como ya sabemos, dispone de múltiples dispositivos de prueba. Conectamos el led S0 con la señal D2 de la tarjeta Arduino NANO (patilla 5). El interruptor E0 lo conectamos con la señal D3 (patilla 6). Suponemos que la tarjeta de control Arduino NANO está insertada sobre el módulo board del entrenador, y alimentada debidamente como ya se explicó en el tema anterior.

S0

E0

Figura 2-7. Esquema eléctrico para el primer ejemplo La fotografía de la figura 2-8 muestra el montaje práctico realizado sobre el entrenador. Procura emplear cablecillos de diferentes colores para, por ejemplo, distinguir entre las entradas y las salidas.

Figura 2-8. Montaje práctico

2-5


5.2 El programa “Función_SI” En primer lugar vamos a ver qué aspecto tiene un programa escrito en el lenguaje Arduino, sobre su entorno IDE de trabaja. Observa la figura 2-9.

Figura 2-9. Aspecto de un programa en el lenguaje Arduino Vallamos por partes. Ya ves que hemos dividido la pantalla de trabajo en tres secciones. Vamos a detallarlas. Sección 1 Aunque no solemos hacerlo por pura pereza, es una muy buena práctica documentar los programas. Los comentarios sirven para informar de quien es el autor, la empresa, versión del programa, fecha de creación y todo aquello que se considere oportuno. También se puede indicar qué herramientas hardware o software se necesitan para ejecutar el programa y, lo más importante, explicar brevemente qué es lo que hace.

2-6


Podemos escribir cualquier tipo de texto siempre y cuando vaya encerrado entre los signos /* ……… */. También se puede documentar cada sentencia o grupo de sentencias del programa, para explicar qué es lo que hacen. Se suele hacer mediante textos sencillos que van precedidos de los signos //. En, general podemos poner cualquier texto en cualquier lugar del programa. Si es un texto de varias líneas, se encierra entre /* …. */, y si es de una única línea, suele ir precedido de //. Sección 2 En el lenguaje Arduino es necesario incluir la función setup(). Normalmente suele ir al principio del programa. Todas las sentencias que estén incluidas dentro de las llaves, se ejecutan una única vez, al iniciar el sistema. Por este motivo aquí suelen ponerse las funciones de configuración, como por ejemplo: void setup() { pinMode( 2 , OUTPUT ); } La señal D2 queda configurada como salida y no es muy probable que esta situación cambie a lo largo de un mismo programa. Puedes poner cualquier tipo de función, pero recuerda: sólo se ejecutan una vez. En ocasiones quizá no necesites configurar nada. En este caso, aunque vacía, también es necesario ponerla: void Setup() { } Sección 3 Esta función también es imprescindible y contiene el cuerpo principal de nuestro programa. Todas las funciones que lo componen deben estar cerradas entre las llaves. En nuestro ejemplo: Void loop() { digitalWrite( 2, digitalRead(3)); } Todas las funciones que estén incluidas entre las llaves {……} se ejecutan de forma indefinida, desde la primera a la última y de nuevo la primera. En nuestro ejemplo, la lectura de la entrada D3 y la escritura sobre la salida D2, se ejecutan constantemente a la velocidad propia del controlador. En otros lenguajes de alto nivel como el C, está función también es imprescindible y suele recibir el nombre de “main()”. 5-3 Grabación del programa Una vez tenemos escrito nuestro programa, el siguiente paso es transferirlo a la memoria Flash del controlador. Es una tarea muy sencilla. Basta con pulsar el botón “Cargar” del entorno de trabajo IDE de Arduino. Transcurrido un cierto tiempo, nos aparecerá un mensaje de “Carga terminada”, así como un resumen de la memoria que consume nuestro programa sobre el total disponible. Ver de nuevo la figura 2-9. Es importante que sepas que, una vez que cargas un programa en el controlador, este se mantiene por tiempo indefinido aunque desconectes la alimentación. La única forma de borrarlo es cargando otro programa nuevo.

2-7


5-4 Comprobación Es el último paso. Es la hora de comprobar si todo, tanto el hardware como el software, funciona correctamente. Nuestro actual ejemplo es muy sencillo de verificar. Basta que introduzcas un nivel “1” con el interruptor E0 (interruptor hacia arriba). El led S0 se debe iluminar. Cuando introduces un nivel “0” (interruptor E0 hacia abajo), el led se apaga. Debes tener en cuenta que a la velocidad que el controlador ejecuta nuestro programa, cualquier cambio que se produzca en la entrada D3 (interruptor E0), repercute inmediatamente sobre la salida D2 (Led S0). En este instante seguro que te estás cuestionando si es necesario utilizar un controlador para iluminar una simple bombilla mediante un interruptor. Tiempo al tiempo, ya se irán complicando los programas e irás viendo las casi infinitas posibilidades que posee. 5.5 Trabajo personal No te limites a comprobar el funcionamiento de los ejemplos que te vamos a ir proponiendo. Casi seguro que funcionan. Lo interesante sería que, además de estudiarlos, los modifiques a tu gusto y los adaptes a tus necesidades con objeto de que vayas cogiendo el hábito de la programación. Por ejemplo, puedes modificar tanto el esquema eléctrico como el programa anterior para controlar el encendido de varios leds mediante varios interruptores. Te propongo controlar cuatro leds de salida conectados con las señales D2, D3, D3 y D4, mediante 4 interruptores conectados con las señales D5, D6, D7 y D8 del controlador. Dibuja a continuación el esquema eléctrico y escribe el programa correspondiente.

2-8


6.- PRINCIPALES FUNCIONES LOGICAS En el mundo digital es muy frecuente hacer ciertas operaciones llamadas “Funciones lógicas”. Realmente, el ejemplo anterior respondía a una de ellas: la función “SI”. En la figura 2-10 su resume el funcionamiento. La “tabla de la verdad” resume el valor binario de la salida S, en función del valor binario de la entrada E. Es muy sencillo. Si E=0  S=0, si E=1  S=1. También se representa el diagrama de tiempos. Si lo miras con cuidado verás que equivale a la tabla de la verdad. Por último se muestra el símbolo eléctrico que se emplea para esta función. Figura 2-10 La función lógica SI El funcionamiento del programa “Función_SI” del ejemplo anterior respondía exactamente a esta tabla de la verdad. También podemos establecer la ecuación lógica para esta función:

= 6-1 Función lógica NO Se trata de lo contrario a la función SI. También se le suele llamar función “NOT”. En la figura 2-11 se resume su funcionamiento. La salida S es lo contrario de la entrada E. Si E=0  S=1 y si E=1  S=0. Analiza la tabla de la verdad y el correspondiente diagrama de tiempos. Figura 2-11. La función NOT

El símbolo “ ! ” se emplea para expresar la función NO al escribir nuestros programas. Dicha función responde a la siguiente ecuación lógica:

= Estudia el siguiente programa, “Función_NO”. Lo escribes y lo grabas. void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, ! digitalRead(3)); //D2 e la función NO con D3 } Comprueba que cuando el interruptor E0 está a “0” (hacia abajo), el led S0 está ………………………………… Comprueba que cuando el interruptor E0 está a “1” (hacia arriba), el led S0 está ………………………………… ¿Cuál es la diferencia con respecto al ejemplo previo? ……………………………………………………………….. ………………………………………………………………………………………………………………………………….

2-9


6-2 Función lógica Y Se le conoce también como función AND y su funcionamiento se resume en la figura 2-12. La salida S es “1” cuando las entradas E1 y E2 también están a nivel “1”. Emplearemos el símbolo “ & ” en nuestros programas y se dice que realiza un producto lógico. Su ecuación responde a:

=

∙ +5Vcc

La patilla 5 de la tarjeta de control Arduino NANO se corresponde con la señal D2 y se conecta con el led S0 del entrenador.

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Realizar el montaje representado en el esquema eléctrico de la figura 213. Este mismo montaje lo vamos a emplear en los siguientes ejemplos con los que vamos a finalizar el presente tema.


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Figura 2-12. La función Y (AND)

Las patillas 6 y 7 corresponden a las señales D3 y D4 y se conectan con los interruptores E2 y E1 del entrenador Universal Trainer. S0

E2

E1

Figura 2-13. Esquema para experimentar con las funciones lógicas

La fotografía de la figura 2-14 muestra el montaje práctico sobre el entrenador.


Aquí tienes el programa de ejemplo “Función_AND”. Lo estudias, lo escribes y lo grabas sobre la tarjeta controladora Arduino NANO.

2 - 10


void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, digitalRead(3) & digitalRead(4)); //Función AND entre D3 y D4 } Comprueba que si cualquier entrada está a “0”, la salida se mantiene a nivel lógico……………. La salida es de nivel lógico ……………… cuando ambas entradas están a nivel ………………..

6-3 Función O También se le conoce como función “OR” y su funcionamiento se representa en la figura 2-15. La salida S es “1” cuando cualquiera de las entradas E1 o E2, o ambas, están a nivel “1”. Emplearemos el símbolo “ | ” en nuestros programas y se dice que realiza la suma lógica (que no aritmética). Su ecuación responde a:

=

+

Figura 2-15. La función o (OR) Emplearemos el mismo esquema eléctrico y el mismo montaje práctico que se mostraba en las figuras 2-13 y 2-14. Analiza y escribe el ejemplo “Funcion_OR” que se muestra a continuación. Grábalo y verifica su funcionamiento. void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, digitalRead(3) | digitalRead(4)); //Función OR entre D3 y D4 } Comprueba que la salida es “0” cuando las entradas están a nivel …………………………. Si cualquiera de las entradas está a “1”, la salida queda a nivel …………………………….. La salida es “1” cuando ambas entradas están a nivel lógico ………………………………..

2 - 11


7.- FUNCIONES LOGICAS DERIVADAS Como consecuencia de combinar entre sí las funciones lógicas anteriores, podemos obtener otras funciones lógicas derivadas. Vamos a estudiarlas a continuación. 7-1 Función NO-Y También se le conoce como función “NAND” y es consecuencia de combinar una función AND y una función NOT. Su funcionamiento se representa en la figura 2-16. La salida S es “1” cuando cualquiera de las entradas E1 o E2, o ambas, están a nivel “0”. Su ecuación responde a:

=

∙ Figura 2-16. Función NAND

Se trata de una función AND (&) a cuya salida se le aplica una función NOT (!). El programa “Función_NAND” puede ser algo así como esto. void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, ! (digitalRead(3) & digitalRead(4))); //Función NAND entre D3 y D4 } Observa con cuidado los paréntesis. Siempre se ejecutan las funciones que estén en los paréntesis más internos. En este caso se leen las entradas D3 y D4 y se realiza la función AND (&) con ellas. A continuación, con el resultado obtenido, se realiza la función NOT (!) y el resultado se escribe sobre la salida D2. Escribe y carga el programa sobre la tarjeta Arduino NANO. Comprueba el funcionamiento. 7-2 Función NO-O También se le conoce como función “NOR” y es consecuencia de combinar una función OR y una función NOT. Su funcionamiento se representa en la figura 2-17. La salida S es “1” cuando las entradas E1 y E2 están a nivel “0”. Su ecuación responde a:

=

+

Figura 2-17. Función NOR Se trata de una función OR (|) a cuya salida se le aplica una función NOT (!). Realiza una suma lógica (que no aritmética) invertida. El programa “Función_NOR” que resuelve esta ecuación puede ser el siguiente.

2 - 12


void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, ! (digitalRead(3) | digitalRead(4))); //Función NOR entre D3 y D4 } Observa con cuidado los paréntesis. Siempre se ejecutan las funciones que estén en los paréntesis más internos. En este caso se leen las entradas D3 y D4 y se realiza la función OR (|) con ellas. A continuación, con el resultado obtenido, se realiza la función NOT (!) y el resultado final se escribe sobre la salida D2. Escribe y carga el programa, y comprueba el funcionamiento. 7-3 Función Exclusiva-O También se le conoce como función “EOR” o bien “XOR” y es consecuencia de combinar funciones AND, OR y NOT. Su funcionamiento se representa en la figura 2-18. La salida S es “1” cuando el número de las entradas E1 y E2 que valen “1” es impar. Su ecuación responde a:

=(

)∙

)+(

∙(

) Figura 2-18. La función XOR

Una función AND realiza el producto lógico de las entradas E1 invertida y E2. Otra función AND realiza el producto de E1 y E2 invertida. Con el resultado de ambas funciones AND se realiza una suma lógica (que no aritmética) mediante una función OR que ofrece el resultado final. Fíjate en los paréntesis del programa de ejemplo “Función_XOR”, que resuelve la ecuación. void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, (( ! digitalRead(3) & digitalRead(4)) | (digitalRead(3) & ! digitalRead(4)))); //Función XOR } Lee e invierte (!) el estado de la entrada D3 y realiza la función AND (&) con D4. Luego lee e invierte (!) D4 y realiza la función AND (&) con D3. Con los resultados de ambas funciones AND se realiza una función OR (|), cuyo resultado final se escribe sobre la salida D2.

2 - 13


7-4 Función NO-Exclusiva-O También se le conoce como función “XNOR” y es consecuencia de combinar funciones AND, OR y NOT. Su funcionamiento se representa en la figura 2-19. La salida S es “1” cuando el número de las entradas E1 y E2 que valen “1” es par, lo contrario de la función XOR. Su ecuación responde a:

=(

)∙

+

∙(

)

Figura 2-19. La función XNOR Una función AND realiza el producto lógico de las entradas E1 invertida y E2. Otra función AND realiza el producto de E1 y E2 invertida. Con el resultado de ambas funciones AND se realiza una suma lógica (que no aritmética) mediante una función OR. El resultado de esta función OR se invierte para obtener el resultado final. Fíjate en los paréntesis del programa de ejemplo “Función_XNOR”, que resuelve la ecuación. void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2, ! (( ! digitalRead(3) & digitalRead(4)) | (digitalRead(3) & ! digitalRead(4)))); XNOR entre D3 y D4 }

//Función

Lee e invierte (!) el estado de la entrada D3 y realiza la función AND (&) con D4. Luego lee e invierte (!) D4 y realiza la función AND (&) con D3. Con los resultados de ambas funciones AND se realiza una función OR (|). El resultado de esta función OR se vuelve a invertir (!) para obtener el resultado final que se escribe sobre la salida D2. 8.- LOS PUERTOS Hasta el momento, todas las líneas de entrada o salida de nuestro controlador Arduino NANO, se han manipulado de forma individual. Mediante las sentencias pinMode(), digitalRead() y digitalWrite() podemos configurar, leer y escribir cualquiera de las 14 líneas de E/S digitales numeradas de la D0 a la D13. Es una forma muy sencilla de controlar ciertos periféricos como pueden ser pulsadores, interruptores, leds, relés, etc…, pero SIEMPRE de forma individual. Se lee o se escribe sobre una determinada línea, valores de un único bit: el “0” o el “1”. Sin embargo, hay ocasiones en que necesitaremos poder leer o escribir en algún periférico, varios bits AL MISMO TIEMPO: una pantalla, un display de 7 segmentos o, por ejemplo, un conjunto de relés que deben reaccionar al unísono. Hacerlo mediante las funciones que conocemos no es recomendable ya que solo pueden manipular un bit cada vez. En primer lugar debemos saber que todas las líneas del Arduino NANO se distribuyen o agrupan en lo que se denominan “Puertos”. Cada puerto tiene 8 bits. La figura 2-20 nos muestra qué puertos tenemos y qué líneas de E/S los forman. Figura 2-20. Los puertos de E/S

2 - 14


De las 14 líneas de E/S que dispone Arduino NANO, 8 de ellas se encuentran en el Puerto D. Se trata de las líneas digitales D0-D7 y se encuentran en las patillas 1, 2, 5, 6, 7, 8, 9 y 10 del controlador respectivamente. Las 6 patillas de E/S restantes se encuentran en el Puerto B. Corresponden a las líneas digitales D8-D13 y se encuentran en las patillas 11 a la 16. Se recomienda repasar la figura 1-9. Los 8 bits del Puerto C se corresponden con las 8 entradas analógicas A0-A7. Se corresponden con las patillas 19-26 respectivamente. Se recomienda repasar la figura 1-9. A partir de este momento, si conseguimos leer o escribir en cualquiera de esos puertos, estaremos haciendo transferencias de datos de 8 bits simultáneamente, y no de un solo bit como lo hemos venido haciendo hasta ahora. Cada puerto se controla mediante 3 registros a través de los cuales podemos configurarlo como entrada o salida, leer un valor de 8 bits procedentes de las patillas de un puerto de entrada o escribir un valor de 8 bits sobre las patillas de un puerto de salida. La siguiente tabla resume dichos registros. PUERTO

REGISTRO DDRD

PUERTO D PORTD PIND DDRB PUERTO B PORTB PINB DDRC PUERTO C PORTC PINC

DESCRIPCION Registro para la configuración de las líneas D0-D7 como entrada o como salida. Un bit “1” configura una patilla como salida, un “0” como entrada. Es de lectura/escritura. Registro de salida de datos. Lo que en él se almacene sale por las patillas de salida D0-D7. Es de lectura/escritura. Registro de entrada de datos. El valor presente en las patillas de entrada D0-D7 se puede leer desde este registro. Es de solo lectura. Registro para la configuración de las líneas D8-D13 como entrada o como salida. Un bit “1” configura la patilla como salida, un “0” como entrada. Es de lectura/escritura. Registro de salida de datos. Lo que en él se almacene sale por las patillas de salida D8-D13. Es de lectura/escritura. Registro de entrada de datos. El valor presente en las patillas de entrada D8-D13 se puede leer desde este registro. Es de solo lectura. Registro para la configuración de las líneas A0-A7 como entrada o como salida. Un bit “1” configura la patilla como salida, un “0” como entrada. Es de lectura/escritura. Registro de salida de datos. Lo que en él se almacene sale por las patillas de salida A0-A7. Es de lectura/escritura. Registro de entrada de datos. El valor presente en las patillas de entrada A0-A7 se puede leer desde este registro. Es de solo lectura.

El lenguaje de programación Arduino permite manejar esos registros en forma de variables. Podemos leer el valor que contienen en un momento dado y también escribir nuevos valores en ellos. Un ejemplo vale más que mil palabras. Ejemplos: DDRD = B00001111;

Escribe el valor binario (B) sobre el registro DDRD. Esto configura las líneas D0-D3 como salida y las líneas D4-D7 como entradas. PORTD = B00000110; Saca el valor binario por las líneas de salida D0-D3. D1 y D2 se ponen a nivel “1”; D0 y D3 se ponen a nivel “0”. DDRB = 0; Las líneas D8-D13 del Puerto B se configuran como entradas. A = PINB; La variable A se carga con el valor presente en las líneas de entrada del Puerto B Ya ves que es muy sencillo. Basta con expresar qué valores quieres almacenar en cada registro para que puedas, bien configurarlo, o bien sacar un determinado valor por sus correspondientes patillas. Dicho valor lo puedes expresar en binario (B00001111), en hexadecimal (0xF) o bien en decimal (15). Todos ellos son equivalentes. La opción en binario es especialmente útil en estos casos.

2 - 15


NOTA: El uso de esta técnica nos permite actuar simultáneamente sobre varias líneas de entrada o salida, pero puede provocar ciertos problemas. Ten en cuenta que algunas líneas tienen otras funciones. Por ejemplo, D0 y D1 pueden ser usadas como recepción (Rx) y transmisión (Tx) en serie. D5 y D6 pueden ser salidas PWM, la línea D4 puede ser la señal SDA en comunicaciones I2C, etc… Estas funciones son gestionadas por ciertas sentencias del propio lenguaje Arduino. Ahora bien, si cambiamos sus configuraciones esas sentencias pueden no funcionar correctamente. Si no es estrictamente necesario, es mejor usar las sentencias pinMode(), digitalRead() y digitalWrite() ya conocidas. 8-1 Ejemplo: “Leer_Puerto” +5Vcc


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Observa el esquema del montaje de la figura 2-21. Tenemos 4 interruptores, E3:E0, conectados con las líneas D11:D8 respectivamente. Estas se encuentran en el Puerto B y habrá que configurarlas como entradas. También se emplean los leds S3:S0 del laboratorio Universal Trainer, que se conectan con las líneas D3:D0 respectivamente. Estas se encuentran en el Puerto D y habrá que configurarlas como salidas.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

E3

S3

S2

S0

S1

E2

El programa lee simultáneamente el estado lógico de los 4 interruptores de entrada y lo saca simultáneamente por los 4 leds de salida. Si un interruptor cualquiera, por ejemplo E2, está a nivel “1”, el led correspondiente, S2, se ilumina. Si el interruptor está a “0”, el led se apaga.

E1 E0

Figura 2-21. Esquema de montaje

Ahora echemos un vistazo al programa “Leer_Puerto”. void setup() { DDRD = B00001111; DDRB = 0; } void loop() { PORTD = PINB; }

//D3:D0 salidas //D11:D8 entradas

//Lee las entradas D11:D8 y lo guarda en las salidas D3:D0

En la función void setup() configuramos las entradas y salidas. En DDRD se configura que las líneas D3:D0 actúan como salidas. En DDRB se configuran todas las líneas como entradas. Aunque en este caso sólo se emplean las líneas D11:D8, siempre es recomendable configurar también como entradas, aquellas líneas que no se usen. La función void loop() es el programa principal. Simplemente carga en PORTD (salidas D3:D0) el resultado de leer PINB (entradas D11:D8). Tanto la lectura de las cuatro entradas como la escritura sobre las cuatro salidas se hace simultáneamente. Si hubiéramos empleado las sentencias digitalRead() y digitalWrite() el programa hubiera sido bastante más largo y menos eficiente. Tendríamos que hacer tantas lecturas y escrituras como líneas queramos explorar. Además, esas lecturas y escrituras se harían de una en una, no de forma simultánea.

2 - 16


8-2 Ejemplo: “Calculadora_Binaria”

Realiza el montaje correspondiente al esquema de la figura 222. Los interruptores E3:E0 se conectan con las líneas D11:D8 respectivamente. Se configurarán como entradas. Con ellos vamos a introducir, a modo de dato variable, un número binario de 4 bits que puede ir desde 0000 (0) hasta 1111 (15).


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

E3

Los 8 leds S7:S0 del laboratorio Universal Trainer se conectan con las líneas D7:D0 que se configuran como salidas. En estos leds vamos a visualizar, en binario, el resultado de realizar diferentes operaciones aritméticas entre el valor binario introducido por los interruptores, y diferentes constantes establecidas en el programa.

E2 E1

S7

S6

S5

S4

S3

S2

S0

S1

E0

Por ejemplo, si con los interruptores introducimos en binario el valor 1001 (9), y le sumamos la constante 0101 (5), el resultado que veremos en los leds será 00001110 (14).

Figura 2-22. Esquema de la “Calculadora_Binaria”

Miremos el cuerpo principal del programa: void loop() { PORTD = (PINB & B00001111) + 5; //Suma 5 al valor de las entradas D11:D8 } Al leer el Puerto B (PINB) se obtiene el estado lógico de TODAS sus líneas de entrada (que son 6). Sin embargo en este ejemplo solo nos interesa el estado de las líneas D11:D8 (las 4 de menos peso), a las que hemos conectado los 4 interruptores. Para evitar leer valores impredecibles en las líneas no conectadas, es muy frecuente emplear una función lógica, en este ejemplo la función AND, con objeto de descartarlas (PINB & B00001111). El resultado de la lectura de esas entradas siempre será B0000XXXX. Modifica convenientemente el programa para realizar las operaciones que se proponen en la siguiente tabla. Anota en ella los diferentes resultados de salida. OPERACION

Sumar 9

Restar 3

Multiplicar 13

Dividir 4

ENTRADA E3:E0 DECIMAL 1001 9 0010 2 1111 15 0110 6 1111 15 0010 2 0110 5 1111 15 1000 8 0110 6 1100 12 1000 8

SALIDA S7:S0 DECIMAL

2 - 17


2 - 18

ARDUINO: La tecnología al alcance de todos TEMA 3: Temporizaciones, expresiones y sonido www.microcontroladores.com

TEMA 3: Temporizaciones, expresiones y sonido,

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

De momento únicamente vamos a emplear el led S0 del entrenador, que lo conectaremos con la señal D2 (patilla 5) del controlador Arduino NANO.


Es posible que hasta este momento no te hayas dado cuenta de la gran velocidad a la que trabajan los controladores. Nuestro Arduino NANO no podía ser menos. Monta el circuito de prueba según el esquema mostrado en la figura 3-1.

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

1.- INTRODUCCIÓN

S0

Figura 3-1. Esquema del circuito de prueba A continuación analiza el siguiente programa, lo escribes, lo grabas y lo pruebas: void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2,HIGH); digitalWrite(2,LOW); }

//La salida D2 se pone a "1" //La salida D2 se pone a "0"

Es muy sencillo. La salida D2 se pone a nivel “1” (el led S0 se enciende) y luego la salida D2 se pone a nivel “0” (el led S0 se apaga). Ambas funciones están dentro de la función principal void loop(), por lo que se ejecutan de forma indefinida y el led se estará apagando y encendiendo constantemente. Ahora bien, ¿cómo ves el led S0 de salida? Lo ves permanentemente encendido. ¿Por qué? Porque a la velocidad que trabaja el controlador, el encendido y apagado es tan rápido que la retina de nuestros ojos ve al led siempre encendido. ¡Es una sensación óptica! El led sí que se apaga, pero no lo vemos. Un controlador como el Arduino NANO es capaz de ejecutar cientos de miles de instrucciones por segundo. Es una velocidad tan rápida que, en ocasiones, vamos a tener que obligarle a que realice ciclos de espera o “temporizaciones”. 2.- FUNCIONES DE TEMPORIZACION Una función de temporización en un programa, detiene la ejecución del mismo durante un determinado tiempo. El tiempo que deseamos “perder” se puede expresar en microsegundos o en milisegundos. El lenguaje Arduino de programación dispone de dos funciones para ello. 2-1 Función delayMicroseconds() Realiza una temporización de tantos microsegundos (µS) como se indiquen. Recuerda que: 1 segundo = 1000 mS, y 1 mS = 1000 µS. Así que: 1 segundo = 1.000.000 µS. Sintaxis: delayMicroseconds(n)

3-1


n:

Expresa el número de microsegundos que se desea temporizar. Se trata de un número entero (16 bits) sin signo (“unsigned int”). Actualmente el número más grande que se puede indicar para realizar una temporización con precisión es de 16.383 (aproximadamente 16 mS). Esto puede variar en futuras versiones del lenguaje. Para realizar temporizaciones mayores se recomienda emplear la función delay().

Ejemplos: A=100; delayMicroseconds(A); delayMicroseconds(1000);

//Temporiza 100 µS = 0.1 mS = 0.0001 segundos //Temporiza 1000 µS = 1 mS = 0,001 segundos

2-2 Función delay() Realiza una temporización de tantos milisegundos (mS) como se indiquen. Recuerda que: 1 segundo = 1000 mS, y 1 mS = 1000 µS. Sintaxis: delay(n) n:

Expresa el número de milisegundos que se desea temporizar. Se trata de un número que puede ser un entero largo (32 bits) sin signo (“unsigned long”). Un número entero largo, con sus 32 bits, ocupa 4 32 bytes y puede representar un valor desde 0 hasta 4.294.967.295 (2 -1).

Ejemplos: A=100; delay(A); delay(1000); delay(60000);

//Temporiza 100 mS = 0,1 segundo //Temporiza 1000 mS = 1 segundo //Temporiza 60000 mS = 60 segundos = 1 minuto

3.- EJEMPLO: INTERMITENCIA El programa “Intermitencia” es una versión mejorada del ejemplo anterior. Observa que se intercala una temporización cada vez que se enciende o apaga el led. Se parece al programa “Test” que vimos en el Tema 1. int Tiempo=1000;

//Variable con el valor de la temporización

void setup() { pinMode( 2 , OUTPUT); //D2 Salida } void loop() { digitalWrite(2,HIGH); delay(Tiempo); digitalWrite(2,LOW); delay(Tiempo); }

//La salida D2 se pone a "1" //Temporiza //La salida D2 se pone a "0" //Temporiza

Cuando lo cargues sobre el controlador Arduino NANO, ahora sí que puedes apreciar perfectamente que el led se enciende y apaga a intervalos de un segundo.

3-2


El ejemplo crea una variable, “Tiempo”, a la que se le carga con el valor de temporización deseado, en este caso 1000 mS = 1 seg. El valor de esa variable se puede modificar para hacer una intermitencia más o menos rápida. Cada vez que se cambie, debes volver a cargar el programa sobre el controlador. 3-1 Trabajo personal Puedes modificar el valor de la variable “Tiempo” tanto como desees. Proponemos que lo vayas reduciendo de forma sucesiva hasta que no se aprecie la intermitencia del led. Anota aquí el valor de “Tiempo” a partir del cual el led lo ves permanentemente iluminado. Valor: ……………………………….………………………………………………………………………………… 4.- MAS EJEMPLOS Mediante una serie de ejemplos, vamos a seguir jugando con las temporizaciones. Puedes usar tu imaginación para realizar programas cada vez más complejos y llamativos. 4-1 El “Faro” Se trata de un ejemplo muy sencillo que trata de simular el funcionamiento de un faro o baliza que señala su posición, mediante una serie de destellos regulares. En el ejemplo se producen tres destellos rápidos seguidos de una pausa de 1.5 segundos. 4-1-1 Trabajo personal  

Modificar los tiempos de los destellos y de la pausa. Hacer un programa con una secuencia de cinco destellos.

Más adelante aprenderás funciones y técnicas de programación que te permitirán escribir este mismo programa con muchas menos instrucciones, haciendo que sea más óptimo y consuma menos memoria del controlador. 4-2 “Juego de luces”

S2 S1 S0


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

El programa enciende secuencialmente, de derecha a izquierda, desde S0 a S3, cada uno de los leds, dando una sensación de movimiento. Ver el montaje en la figura 3-3.

S3

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Otro sencillo y vistoso ejemplo. Se trata de hacer un juego de luces. Vamos a emplear cuatro leds del entrenador, S3:S0, que se conectan respectivamente con las salidas D2:D5 de nuestro controlador, tal y como se muestra en el esquema de la figura 3-2.

Figura 3-2. Esquema del “Juego de luces”


3-3


4-2-1 Trabajo personal   

Varía la temporización al objeto de variar el efecto de “movimiento” de las luces. Modifica el programa para que el movimiento sea ahora de izquierda a derecha. Más difícil todavía: combina ambos movimientos. Es decir desplaza de izquierda a derecha y seguidamente de derecha a izquierda.

4-3 “Semáforo V1”

El pulsador E10 se conecta con la entrada de RESET. Se emplea para iniciar la secuencia de funcionamiento del semáforo.

VERDE S2 AMBAR S1 ROJO S0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15


ARDUINO NANO

El led S2 se conecta con la señal D2 y emula a la luz verde. El led S1 se conecta con D3 y emula a la luz ámbar. S0 se conecta con D4 y emula a la luz roja.

E10 RESET

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

Es la primera versión de un programa que trata de emular el funcionamiento de un semáforo. El esquema de conexiones se muestra en la figura 3-4.

Figura 3-4. Esquema del semáforo.

Se recomienda grabar el programa antes de conectar el pulsador RESET en la patilla 3 Si te fijas en el programa verás un detalle importante. Todas las funciones que lo componen están incluidas en la función void setup(). Esto quiere decir que sólo se van a ejecutar una única vez: cada vez que se reinicie el sistema. Por su parte, la función void loop() está vacía. No contiene ninguna instrucción para ejecutar. Cuando el controlador entra en ella, se queda sin hacer nada en un bucle infinito. En otras palabras, la secuencia del semáforo sólo se produce cuando pulses el botón RESET de reinicio. 4-3-1 Trabajo personal  

Modifica los tiempos en que cada luz permanece encendida y/o apagada. Si te fijas en un semáforo convencional, verás que antes de que la luz verde pase a ámbar, y la ámbar pase a roja, ambas luces realizan una serie de destellos de aviso. ¡Date prisa!

5.- EXPRESIONES A estas alturas habrás observado que las instrucciones que hemos visto hasta el momento, y la mayoría de las instrucciones del lenguaje Arduino, necesitan uno o más parámetros u operandos para su correcto funcionamiento. Estos van cerrados entre paréntesis y separados por “,”. De momento hemos estudiado:     

pinMode (pin, modo) digitalRead (pin) digitalWriyte (pin,valor) delay (tiempo) delayMicroseconds (tiempo)

Hay que indicar nº de patilla y si es entrada o salida Hay que indicar nº de patilla a leer Hay que indicar nº de patilla y valor a sacar por ella Indicamos el tiempo en milisegundos que deseamos temporizar Indicamos el tiempo en microsegundos que deseamos temporizar

Esos parámetros los podemos indicar de diferentes formas. Es más, algunas de ellas ya las hemos usado en los diferentes programas de ejemplo propuestos. Llamaremos “Expresión” a la forma en que vamos a indicar esos parámetros. Básicamente utilizaremos tres formas:

3-4




Constante: El valor del parámetro se proporciona directamente en la propia función. Por ejemplo: delay(1000). Temporiza directamente 1000 mili segundos.



Variable: El valor del parámetro está previamente definido y guardado en una variable. Por ejemplo: delay(Tiempo). El valor a temporizar está guardado en la variable “Tiempo” y el controlador debe ir a buscarlo.



Operación: El valor del parámetro se obtiene como consecuencia de realizar cualquier tipo de operación aritmético/lógica entre variables y/o constantes. Por ejemplo: delay((Tiempo+1000)/3). Temporiza tantos milisegundos como resulten de calcular el valor de la variable “Tiempo” más 1000 y todo ello dividido entre 3.

No se puede decir cuál de estas formas de expresar los parámetros o datos es la mejor. Las usaremos en cada caso según mejor nos convenga. 5-1 Constantes Cuando en un programa se utiliza un valor que siempre es fijo y nunca varía, se emplea como un dato “constante”. Si en un momento dado tienes que realizar una temporización que siempre es igual, por ejemplo de 1 segundo, emplearás delay(1000). El controlador ejecuta esa instrucción siempre con el mismo parámetro (1000). NO se puede variar dinámicamente durante la ejecución del programa. La única forma de cambiarlo es modificando el programa y grabándolo nuevamente en la memoria del controlador. Otro ejemplo. Imagina que debes realizar un programa para calcular la longitud de una circunferencia en función de un diámetro dado. La ecuación a resolver sería: = ∙ , donde: l = El resultado con la longitud de la circunferencia calculada d = Diámetro de esa circunferencia π = el valor 3.1416 A la vista del ejemplo tú mismo puedes responder: ¿Qué dato es constante? …………………..……… ¿y cuál es variable? ……………………………………. Los datos constantes forman parte del propio programa y se encuentran como parámetros en las propias instrucciones o funciones del mismo. Se guardan por tanto en la memoria FLASH de programa del controlador. Se trata de una memoria NO VOLATIL de sólo lectura. No se puede modificar (salvo cuando se graba el programa) y su contenido se mantiene incluso cuando se desconecta la alimentación. En algunos de los ejemplos que ya hemos hecho se han empleado palabras como: HIGH o LOW, INPUT u OUTPUT o TRUE o FALSE. Son palabras “clave” del lenguaje Arduino tratadas como “constantes”. 5-2 Variables Las variables son espacios de memoria RAM que se reservan para guardar datos. Cómo se muestra en la figura 3-5, te las puedes imaginar como un conjunto de recipientes donde podemos guardar información de diferente tipo para usarla posteriormente cuando nos haga falta. La memoria RAM es una memoria que se puede leer y escribir tantas veces como necesitemos. Su contenido SI se puede modificar dinámicamente durante la ejecución de un programa. Es volátil y toda su información desaparece cuando falta la tensión general de alimentación. Figura 3-5. Variables

3-5


Como ya hemos hecho en alguno de los ejemplos anteriores, las variables han de ser declaradas previamente para luego poder ser utilizadas, según la siguiente sintaxis: tipo nombre = valor tipo:

Establece qué tipo de información va a contener la variable. Puede ser números, letras o textos.

nombre:

Es el nombre que vamos a asignar a la variable y con el que la vamos referenciar en lo sucesivo a lo largo del programa. Lo ideal es que se empleen nombres no muy largos y que recuerden un poco su contenido. El nombre de una variable debe empezar siempre por una letra, no por un número y no debe contener espacios en blanco.

valor:

Es el valor que metemos en la variable o recipiente. Es opcional. Podemos crear una variable vacía, sin introducir ninguna información en su interior. Simplemente le hacemos una reserva en la memoria RAM del controlador para cuando la necesitemos. La siguiente tabla resume algunos de los tipos más corrientes para la declaración de variables. TIPO char

BYTES 1

byte o unsigned char int

1

unsigned int o word long

2

unsigned long

4

float

4

2

4

DESCRIPCION Almacena un valor del tipo carácter (8 bits) que debe ir entre comilla simple (‘). Es con signo y codifica números del rango -128 a +127 Almacena un número de 8 bits sin signo del 8 rango 0 a 255 (2 -1) Es el tipo por defecto. Almacena un número de 16 bits con signo en el rango de -32768 a +32767. Almacena un número de 16 bits sin signo 16 con un rango de 0 a 65535 (2 -1) Almacena un número de 32 bits con signo en el rango de -2.147.483.648 a +2.147.483.647 Almacena un número de 32 bits sin signo 32 con un rango de 0 a 4.294.967.295 (2 -1) Almacena un número de 32 bits en coma +38 flotante con un máximo de 3.4028235 y un -38 mínimo de 3.4028235

EJEMPLOS char opción = ‘1’ char letra = ‘A’

byte C = 23 byte resultado = C + 18 int C = 2453 int valor = C * 10 unsigned int valor = 12000 * 3 word valor = 12000 * 3 long Contador = -123456789 unsigned long Velocidad_Luz = 299792468 float PI = 3.1416 float L = 4 * PI

En función del tipo de variable que vayamos a crear, debemos saber que se consume una mayor o menor cantidad de memoria RAM. Es conveniente definir adecuadamente una variable según el tipo de información que vaya a contener. Por ejemplo, una variable tipo “long” consume 4 bytes de memoria RAM. Su uso es bastante poco recomendable si la información que va a contener es, supongamos, de tipo byte. La memoria RAM es limitada y un uso inadecuado de variables la puede terminar agotando. Por otra parte si se declara una variable de, por ejemplo tipo byte, y se introduce un valor superior a 255, dicha variable se desbordará, perdiéndose parte de la información. Es algo parecido a lo que le pasará al cuentakilómetros de la figura 3-6. Cuando se desborde vuelve otra vez a 0.

Figura 3-6. Desbordamiento de un cuentakilómetros Por ejemplo, imagina que a una variable tipo byte que contiene el valor 253, se le suma 6. El resultado debiera ser 259, sin embargo vemos que es 3. ¿Por qué? Porque en una variable tipo byte el valor 8 máximo que cabe es de 0 a 255 (2 -1). Luego se desborda, vuelve a 0 y empieza de nuevo.

3-6


Otro tipo de variables son los llamados Arrays. Un array es una colección de variables de cualquiera de los posibles tipos estudiados. Para acceder a una variable en particular dentro de una colección, se debe indicar el índice de la misma. Mira estos ejemplos: 

int Tabla[4] Crea un array llamado “Tabla” capaz de almacenar 4 números de tipo int. Ocupa por tanto 8 bytes de la memoria RAM. Ver la figura 3-7 Figura 3-7. Array de 4 celdas



int Tabla[ ]={5678,750,1234} Crea el array “Tabla” y almacena los valores indicados, quedando como se muestra en la figura 3-8. Figura 3-8. El array “Tabla”



int Suma = Tabla[0] + Tabla[2] Extrae del array “Tabla” el valor de su variable 0 (5678) y el de su variable 2 (1234). Hace la suma y almacena el resultado (6912) en la variable “Suma”



unsigned int Valores[12] Crea un array llamado “Valores” con capacidad para 12 variables de tipo entero sin signo. Ocupa 24 bytes de memoria RAM en total.



Valores[4] = 12345 En la variable 4 del array “Valores” se introduce el número 12345



char Texto[8] = “ARDUINO” Crea un array de tipo carácter llamado “Texto”. Ocupa 8 bytes de RAM y se almacena la cadena “ARDUINO\o” (\o es el código Null de control). Ver la figura 3-9. Figura 3-9. Un array de texto



char Letra=Texto[2] Extrae la variable 2 del array “Texto” (letra D) y la almacena sobre la variable “Letra”

5-2-1 Tipos de variables Según el lugar del programa donde declares las variables, estas pueden ser “globales” o bien “locales”. Esta distinción puede ser importante cuando empieces a desarrollar programas de cierta complejidad y tamaño. Globales: Son las variables que se declaran o definen fuera de todas las funciones que haya en el programa, incluidas las funciones void setup() y void loop(). En el ejemplo que se muestra en la figura 3-10, las variables “Dato” y “Resultado” son globales. Pueden ser usadas por cualquiera de las funciones existentes en el programa. Locales: Son variables que únicamente pueden ser usadas o vistas dentro de la función en donde se crearon. Se evita así que una variable que se declara en una función, pueda ser utilizada por otra función distinta a ella (excepto que sea una variable global). Figura 3-10. Variables globales y locales

3-7


Una vez que finaliza la ejecución de una función, todas sus variables locales desaparecen hasta que volvamos a usarla. Según la figura, en la función Mi_función_1(), las variables “Tiempo”, “Hora” y “Resultado” son locales. Observa las variables locales del resto de las funciones de la figura 3-10 de ejemplo. 5-3 Operaciones Como ya habrás adivinado, tanto los parámetros que acompañan a las sentencias del lenguaje Arduino, como los valores que cargamos en las variables, pueden obtenerse como resultado de hacer todo tipo de operaciones aritméticas entre variables y/o constantes. Las operaciones matemáticas clásicas son: = + * / %

Asignación Suma Resta Multiplicación División Módulo (el resto de una división entre dos números enteros)

Al igual que cuando operamos nosotros, cualquier expresión se calcula de izquierda a derecha. La multiplicación y la división tienen prioridad sobre la suma y la resta. Se pueden usar los paréntesis para establecer la prioridad deseada en la operación. Mira estos ejemplos:     

3 +5 – 2 = 6 20 - 2 * 3 = 14 y no 54 (20-2) * 3 = 54 y no 14 20 / 2 * 3 = 30 24 / (2 * 3) = 4

    

(12 – 2) + 5 * 3 = 25 y no 45 ((12 – 2) + 5) * 3 = 45 y no 25 13 % 4 = 1 7%5=2 5%5=0

Teniendo en cuenta todo lo visto en esta sección, a partir de ahora podrás determinar los parámetros que usan las funciones del lenguaje Arduino, de una forma mucho más flexible y potente. Fíjate en los siguientes ejemplos y trata de responder a las preguntas. byte Luz = 3; pinMode(Luz+1,OUTPUT); digitalRead(Luz); digitalWrite((1+Luz)*2,HIGH); ¿Qué patilla se configura como salida?……………………………………………………………………………. ¿Qué patilla se lee?…………………………………………………………………………………………………… ¿Qué patilla se pone a nivel “1”?……………………………………………………………………………………. byte A = 250; byte B; byte C; unsigned int D; A = A + 3; B = (A-200) * 2 / 4; C = A * 2 + 20; D = (A * 100) % 2; A = …………………….; B = ……………………..; C = …………………….; D = …………………….. byte A=10; delay((A+2) * 1000 / 5): La temporización realizada es de ……………………………………………….

3-8


6.- SONIDO Aprovechando que ya sabemos manejar las entradas y salidas digitales, es el momento de ver cómo podemos generar sonido con nuestro controlador Arduino NANO. Al fin y al cabo una señal de sonido no es otra cosa que una señal eléctrica que varía a una determinada frecuencia produciendo diferentes tonos. Mira la figura 3-11.

Figura 3-11. Señal de diferentes frecuencias y tonos Esta señal la podemos aplicar a un transductor como puede ser un altavoz. Este traduce la señal eléctrica en una serie de movimientos mecánicos que producen cambios de presión, vibraciones u ondas en el aire, llegando así hasta nuestro oído. El oído humano es capaz de percibir y escuchar vibraciones que van desde los 20Hz (Hertzios) has los 20000Hz (o 20KHz). Las vibraciones por debajo de los 20Hz reciben el nombre de “infrasonidos”, y por encima de los 20KHz, “ultrasonidos”. Teóricamente el oído humano no es capaz de percibir ninguno de esos sonidos, aunque algunos animales sí. Según la figura anterior, vamos a generar señales audibles compuestas de niveles lógicos: “1” y “0”. Esto ya lo sabemos hacer. Solo nos queda por calcular la frecuencia que deseamos para esa señal. Es fácil: 1. A partir de la frecuencia F deseada (por ejemplo 1000Hz), calculamos lo que debe durar un ciclo. Un ciclo es la parte que se repite de la señal (nivel “1” y nivel “0”). También se le llama “periodo” o T. =

=

= .

=

=

2. Ahora calculamos el semiperiodo S, o lo que es igual, el tiempo que la señal va a estar a nivel “1” y a nivel “0”. =

=

.

= .

= .

=

Observa el siguiente programa, “Tonos_1”, y verás que no tiene mayor dificultad. Estamos aplicando todo lo que hemos aprendido hasta el momento: float F=1000; float C=1/F; unsigned long T=C*1000000; unsigned long S=T/2;

//Valor de la frecuencia deseada (F) //Calcula la duración del ciclo en segundos //Calcula el periodo T en microsegundos //Calcula el valor del semiperiodo (S)

Creamos diferentes variables. “F” contiene la frecuencia de la señal sonora deseada. En “C” se calcula la duración del ciclo o periodo en segundos, según la fórmula anterior. En “T” tenemos la duración del ciclo o periodo convertida en microsegundos. Finalmente, la variable “S” se carga con la duración del semiperiodo. Todas estas variables están fuera de las funciones void setup() y void loop(), por lo que son variables globales.

3-9


Por lo demás, el cuerpo principal del programa no nos enseña nada nuevo: void loop() { digitalWrite(12,HIGH); delayMicroseconds(S); digitalWrite(12,LOW); delayMicroseconds(S); }

//El altavoz se activa //Temporiza //El altavoz se desactiva //Temporiza

La salida digital 12 se pone a “1”, se temporiza según el valor calculado para el semiperiodo (S), se pone a nivel “0” y se vuelve a temporizar según S. Para probar este ejemplo necesitamos del altavoz que se incluye en el presente módulo. Como se muestra en la figura 3-12, le vamos a colocar o soldar dos cablecillos que nos permitan a su vez conectarlo con la tarjeta de control Arduino NANO. Figura 3-12. El altavoz +5Vcc


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Ahora veamos el esquema eléctrico de conexiones que se muestra en la figura 3-13. Uno de los cablecillos del altavoz se conecta con la patilla D12 de la tarjeta Arduino NANO. Por esta patilla vamos a sacar la señal sonora. El otro de los cablecillos del altavoz se conecta con la señal GND de alimentación.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Figura 3-13. Esquema eléctrico del ejemplo La fotografía de la figura 3-14 muestra el montaje práctico sobre el entrenador Universal Trainer. Figura 3-14. Montaje práctico Prueba a variar la frecuencia modificando en el programa el valor de la variable F. Oirás sonidos con diferentes tonos. A frecuencia bajas, tonos graves; a frecuencias altas, tonos agudos. También puedes hacer un análisis de tus propias capacidades auditivas. Completa la siguiente tabla. Frecuencia (F) Periodo (T) Semiperiodo (S) ¿Lo oyes? (SI/NO)

20 Hz

200 Hz

1 KHz

4 KHz

10 KHz

15 KHz

18 KHz

20 KHz

6-1 Sentencias de sonido Como no podía ser menos, el lenguaje de programación Arduino dispone de sus propias funciones o instrucciones para generar todo tipo de sonidos. Esto facilita enormemente la programación ya que no tendremos que calcular ni periodos ni semiperiodos para una frecuencia deseada. Lo hará el propio lenguaje.

3 - 10


6-1-1 Función tone() Genera una señal de onda cuadrada con la frecuencia y la duración deseada. La frecuencia mínima que puede generar es de 31Hz. La señal de salida es simétrica. El nivel “1” dura lo mismo que el nivel “0”. Sintaxis: tone(pin,frecuencia,duración) pin: frecuencia: duración:

Indica la patilla por donde va generarse la señal audible. Valor entero sin signo que expresa, en hertzios (Hz), la frecuencia de la señal Valor entero sin signo que expresa, en milisegundos, la duración del tono. Es opcional. Si no se indica la salida de la señal o el tono se mantiene permanentemente hasta que se ejecute la función noTone().

Ejemplos: tone(12,1000,1000); tone(3, A + 100,300); tone(6,2500);

Genera una señal o tono de 1000Hz durante 1 segundo por la patilla 12 Genera una señal cuya frecuencia resulta de sumar el contenido de la variable “A” con 100, por la patilla 3. La duración del tono es de 300mS (0.3s). Genera una señal de 2500 Hz por la patilla 6 de forma permanente hasta que se ejecute la función noTone().

6-1-2 Función noTone() Detiene la generación de la señal audible producida por la última función tone() ejecutada en el programa. Sintaxis: noTone(pin) pin:

Indica la patilla por donde se está generando la señal audible que se desea detener.

Ejemplo: tone(6,2500); noTone(6);

Genera una señal audible permanente de 2500Hz por la patilla 6 Interrumpe la señal audible que sale por la patilla 6

6-2 Ejemplo: “Tonos_V2” Graba y prueba el funcionamiento del programa “Tonos_V2”. Se comporta exactamente igual que el programa “Tonos_V1” del ejemplo anterior, pero estarás de acuerdo en que es mucho más sencillo: void loop() { tone(12,F); }

//Genera una señal de frecuencia F por la patilla 12

No solo eso, también es mucho más eficiente. Efectivamente, en el programa “Tonos_V1”, mientras el controlador está temporizando para activar o desactivar la patilla por donde sale la señal audible (la 12),… ¡NO PUEDE ESTAR HACIENDO NINGUNA OTRA TAREA! Sin embargo, si empleamos la función tone(), el controlador realiza los ajustes internos necesarios para sacar la señal deseada y a continuación continúa ejecutando las instrucciones de nuestro programa.

3 - 11


6-3 Ejemplo: “Tonos_V3” Vamos ahora con el ejemplo “Tonos_V3” para corroborar lo que acabamos de decir. En la función void setup() se ha incluido la función tone(12,F). Sabemos por tanto que solo se ejecuta una vez y el controlador queda ajustado para producir permanentemente una señal audible por la patilla 12. Por su parte, la función principal void loop() se limita a activar y desactivar la salida D2 con un intervalo de 0.3 segundos. Monta el circuito mostrado en el esquema de la figura 3-15. Una vez que grabes el programa, comprueba que el tono de 1KHz se mantiene a pesar de que el controlador está metido en un bucle infinito, activando/desactivando la salida D2, donde hemos conectado el led S0 del entrenador.


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

¿Serías capaz de hacer lo mismo pero usando la técnica empleada en el programa “Tonos_V1”?

Figura 3-15. El ejemplo Tonos_V3 S0

6-4 Ejemplo: “Tonos_V4”

+5Vcc


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Otro ejemplo de uso de la función tone(). Se trata de sacar una señal acústica de aviso cada vez que se reinicie el sistema activando la señal RESET. Se generan tres tonos de diferentes frecuencias y duración.

Figura 3-16. Esquema del ejemplo “Tonos_V4”

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Monta el circuito del esquema de la figura 3-16. Se recomienda que el pulsador E10 lo conectes con la entrada de RESET (patilla 3) después de grabar el programa, para evitar problemas de transferencia entre el PC y la tarjeta de control Arduino NANO.

E10

RESET

6-5 Ejemplo: “Melodías” Naturalmente, con la función tone() del lenguaje Arduino también puedes crear tus propias melodías. Este ejemplo te lo demostrará. Ten en cuenta que a cada nota musical le corresponde una frecuencia. Si sabes solfeo te basta con buscar la relación entre las notas de la partitura con sus correspondientes frecuencias, para poder así reproducir una melodía. Según el sistema latino de notación musical, las notas básicas son siete: “do, re, mi, fa, sol, la, si”. En el sistema inglés de notación, también denominado “denominación literal”, se corresponden con “C, D, E, F, G, A, B” respectivamente. A partir de ellas se obtienen los sostenidos, bemoles y una combinación de todos ellos. Además de las notas (o frecuencias), en una melodía también se debe establecer la duración de cada una así como el intervalo entre una nota y la siguiente. La duración se suele establecer en 1/4, 1/8, etc… de segundo, es decir: 1000 mS / 4, 1000 mS / 8, etc… La duración de una nota se puede establecer en la misma función tone(). El intervalo entre una nota y la siguiente suele ser un 30% de la duración de la misma. Dichos intervalos se pueden conseguir fácilmente mediante la función delay().

3 - 12


El programa del ejemplo reproduce 8 conocidas notas. Todas ellas, salvo en frecuencia, duración e intervalo, son similares. Observa las funciones tone() y delay() de la primera nota. Se corresponde con la nota C4 (262Hz), con una duración de 250 mS y un intervalo de espera del 30% de la duración (325 mS). Te sirve el mismo circuito de la figura 3-16. Acuérdate de grabar el programa antes de conectar el pulsador E10 con la señal de RESET (patilla 3). 6-6 Ejemplo Semáforo_V2 Aquí tienes una segunda versión mejorada del ejemplo del semáforo, el “Semáforo_V2”. Aprovechando lo que ya sabemos sobre el sonido, el programa emula el funcionamiento de un semáforo con señales acústicas para invidentes. La secuencia se inicia al activar la señal de RESET. El encendido secuencial de las diferentes luces va acompañado de sus correspondientes señales acústicas de aviso. Si te fijas, todas las instrucciones del programa se encuentran incluidas en la función void setup(), por lo que únicamente se ejecutan tras reiniciar el sistema mediante el RESET. El programa te puede parecer largo pero no complicado. Con lo que sabemos de momento es lo único que podemos hacer. En el próximo tema vamos a estudiar y a emplear sentencias de control. Con ellas vamos a poder hacer programas mucho más cortos y eficientes. Tiempo al tiempo. En la figura 3-17 se muestra el esquema de conexiones para este ejemplo. No hay mucho que explicar ya que es similar al empleado en ejemplos anteriores. Recuerda que es aconsejable grabar el programa antes de conectar el pulsador E10 con la entrada RESET (patilla 3). E10 RESET

ROJO1 S0

ARDUINO NANO

AMBAR1 S1


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

VERDE1 S2

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Figura 3-17. Esquema para el “Semáforo_V2”

3 - 13


3 - 14

ARDUINO: La tecnología al alcance de todos TEMA 4: Toma de decisiones y sentencias de control www.microcontroladores.com

TEMA 4: Toma de decisiones y sentencias de control: 1.- INTRODUCCIÓN Los seres humanos somos capaces de analizar nuestro entorno y situación y, en función de nuestros intereses, sentimientos, capacidad, intuición, obligación, etc…, tomamos decisiones que nos llevan a realizar una tarea u otra con mayor o menor éxito. Los programas que hemos desarrollado hasta el momento eran programas muy secuenciales. Las instrucciones se van ejecutando una tras otra, desde la primera hasta la última y sin ninguna otra consideración. Sin embargo Arduino, al igual que cualquier otro controlador, también tiene capacidad de tomar decisiones y ejecutar los programas o tareas apropiadas en caso. Ahora bien, Arduino no tiene sentimientos, ni intuición, ni tan siquiera es inteligente. Es una máquina que solo sabe manejar números, y como tal, sus decisiones se toman en base a ellos: cálculos aritméticos/lógicos, comparaciones entre números, estados de las señales digitales de entrada, valores analógicos leídos de un sensor, etc… 1-1 Operadores de comparación Ya sabemos que Arduino puede realizar operaciones aritméticas como sumar y restar diferentes números o datos que podemos expresar en forma de “constantes”, “variables” o combinación de ambas cosas. También puede hacer comparaciones entre datos o entre los resultados que ofrecen a su vez otras funciones. Los operadores de comparación, así como los símbolos que los representan, son los siguientes:      

Igualdad (==) Distinto de (¡=) Menor que (<) Mayor que (>) Menor o igual que (<=) Mayor o igual que (>=)

Como resultado de una comparación, sea del tipo que sea, solo se obtienen dos resultados posibles: verdadero (true) o falso (false). Mira y analiza los siguientes ejemplos: Suponiendo que … char Letra = ‘J’; byte A = 13; int B = 12345; float PI = 3.1416; Entonces … Letra == “J” Letra ¡= “Q” 18 < A A == 8 + 5 B >= A PI * 2 > 8.16 B – 1000 <= A * 12 digitalRead(4) == 1 está a “1”)

//Verdad //Verdad //Falso //Verdad //Verdad //Falso //Falso //Verdad (si la entrada 4

Ahora tú… A + B == 12357 B < A * 1000 A <= 13 A * 2 >= 25 Letra > “K” Letra < “K”

//……………………. //……………………. //……………………. //……………………. //……………………. //…………………….

4-1


1-2 Operadores booleanos Incluso es posible relacionar entre sí varias de las comparaciones o expresiones anteriores. Para ello, Arduino dispone de tres operadores lógicos o “booleanos” que, seguro que te recuerdan algo. Aquí los tienes junto con los símbolos que los representan:   

Y (&&) O (||) NO (¡)

De igual forma, como consecuencia de relacionar dos o más expresiones mediante estos operadores lógicos, también se generan dos posibles resultados: verdadero (true) o falso (false). Observa los siguientes ejemplos. Cada expresión que relacionamos va encerrada entre paréntesis para evitar errores. (Letra == ‘X’) && (A > 10) (A == 10+3) && (B >= 12345) && (Letra ¡= ‘Q’) (B > 12300) || (PI = 3.1412) (A == B) || (A > 10 + 4) ¡(A == B) (digitalRead(4) == 1) && (digitalRead(8)==1)

//Falso //Verdad //Verdad //Falso //Verdad //Verdad si ambas entradas (D4 y D8) está a nivel “1”

2.- SENTENCIA IF (… ) Es la sentencia de control más elemental. Permite evaluar y tomar decisiones en base a expresiones como las que acabamos de ver. En informática, en los esquemas conocidos como “diagramas de flujo”, es muy frecuente emplear símbolos como el mostrado en la figura 4-1, que representa a una toma de decisión. El controlador evalúa la expresión. Si es verdadera ejecuta todas las instrucciones que se encuentren cerradas entre las llaves {… }. Si resulta ser falsa no se ejecutan y el programa sigue su curso. Figura 4-1. Sentencia if (…) Debemos recordar que una expresión puede estar formada por operaciones aritméticas entre constantes y/o variables relacionadas entre sí por operadores de comparación, que a su vez, se relacionan mediante operadores lógicos o booleanos. Repasa los ejemplos anteriores. Sintaxis: if(expresión) { …. …. } expresión:

Establece la condición que Arduino debe evaluar. Puede ser la comparación entre datos constantes y/o variables. Puede haber una o más comparaciones relacionadas entre sí mediante los operadores lógicos. También se pueden comparar los resultados obtenidos al ejecutar operaciones aritméticas u otras funciones del propio lenguaje Arduino.

llaves:

Como en un bocadillo, encierran las sentencias que el controlador debe ejecutar en caso de que se cumpla la condición (true). No hacen falta si únicamente se va a ejecutar una instrucción o sentencia.

4-2


2-1 Ejemplo: “Timbre”


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Veamos un ejemplo muy sencillo que ilustra perfectamente el funcionamiento de la función if(). Se trata de emular un timbre electrónico que se activa al accionar un pulsador. El esquema de la figura 4-2 muestra el montaje a realizar sobre el entrenador Universal Trainer. El pulsador E10 se conecta con la entrada D2 (patilla 5) del controlador. Este pulsador trabaja con lógica inversa. En reposo proporciona nivel “1” y cuando se acciona nivel “0”. El altavoz se conecta con la salida D12 como en anteriores ejemplos.

E10

Figura 4-2. El ejemplo “Timbre”

TIMBRE

void loop() { if(digitalRead(2)==0) { tone(12,400); delay(300); tone(12,300,300); } }

//Si la entrada D2 está a "0" ... //Genera una frecuencia de 400Hz... //... durante 0.3" //Genera una frecuencia de 300Hz durante 0.3"

Si la entrada D2 está a nivel “0” (true) se generan los dos tonos que simulan el timbre. Uno es de 400Hz y el otro de 300Hz. Ambos tienen una duración de 0.3 s. Si la entrada D2 está a nivel “1”, la condición no se cumple (false) y las instrucciones encerradas entre las llaves no se ejecutan. Consejo: Cuando emplees sentencias condicionales en tus programas, es una buena costumbre alinear las llaves de forma que se vea claramente el emparejamiento de la que abre, con la llave que cierra. En el ejemplo se distingue claramente las llaves que abren y cierran la función void loop() principal, y las que corresponden a las de la función if().

3.- SENTENCIA IF( … ) ELSE Se trata de otra sentencia de control que se derivada de la sentencia if() anterior. Permite establecer claramente qué hacer si no se cumple la condición (else). La figura 4-3 puede ayudar a entender su funcionamiento. Se evalúa la expresión o condición. Si ésta se cumple (true), se ejecutan todas las sentencias encerradas entre las llaves: igual que en la función if(). Si la condición NO se cumple (false), se ejecutan todas las instrucciones cerradas entre las llaves que siguen a la palabra else (sino). Una vez ejecutas las instrucciones en cualquiera de los dos casos, la ejecución del programa continua su curso. Figura 4-3. Sentencia if (…) else

4-3


Sintaxis: if(expresión) { …. …. } else { …. …. } expresión:

Establece la condición que Arduino debe evaluar. Puede ser la comparación entre datos constantes y/o variables. Puede haber una o más comparaciones relacionadas entre sí mediante los operadores lógicos. También se pueden comparar los resultados obtenidos al ejecutar operaciones aritméticas u otras funciones del lenguaje Arduino.

llaves:

Engloban a todas las sentencias que el controlador debe ejecutar tanto en caso de que se cumpla la condición (if), como si no se cumple (else). Las llaves no hacen falta si únicamente se necesita ejecutar una instrucción en cada caso, por ejemplo: if (A > 13) A = A + 25; else A = B;

3-1 Ejemplo: “Juego de luces_V2”


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

El programa puede parecerte largo, pero sin embargo es muy sencillo. Mediante la sentencia if(!digitalRead(2)) se lee y evalúa el estado de la entrada digital D2 (interruptor E0). Mediante el uso de las llaves queda bien claro qué instrucciones se ejecutan si se cumple la condición (interruptor = “0”), y cuáles en caso contrario else (interruptor = “1”).

S0

S1

S2

S3

E0

Una nueva versión del juego de luces que hicimos en el tema anterior. Mediante un interruptor se controla si el desplazamiento es a la izquierda o a la derecha. La figura 4-4 muestra el esquema de conexiones. Los leds de salida S3:S0 se conectan con las líneas D3:D6 respectivamente. El interruptor de entrada E0 se conecta con la línea D2. Cuando está a nivel “0” las luces se encienden describiendo una secuencia de derecha a izquierda. Si el interruptor está a nivel “1” la secuencia de encendido es de izquierda a derecha.

Figura 4-4. Esquema para el programa “Juego de luces _V2”

3-2 Ejemplo: “Semáforo_V3” En la figura 4-5 se muestra el esquema para una nueva versión del ejemplo del semáforo, “Semáforo_V3”. Las líneas D3:D5 actúan como salidas y se conectan con los leds S2:S0 que simulan las luces verde, ámbar y roja del semáforo respectivamente. El pulsador E10 del entrenador Universal Trainer se conecta con la línea D2 que actúa como entrada. El pulsador es accionado por el peatón cada vez que desea cruzar la vía.

4-4



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Transcurrido un tiempo de 2 segundos, la luz roja se apaga y comienza la secuencia. Se enciende la luz verde y se generan unos tonos de 1000 Hz, con una duración de 0.5” y una cadencia de 1.1” entre tono y tono. A continuación se enciende la luz ámbar y se generan unos tonos de 1000 Hz, con una duración de 0.4” y una cadencia de 0.7”. Son tonos más breves y rápidos para darle al peatón la sensación de que debe darse prisa al cruzar. Finalmente, se enciende la luz roja con un tono permanente de 2 segundos. Finaliza el tono pero la luz roja se mantiene encendida hasta iniciar una nueva secuencia.

ROJO2 S0

Figura 4-5. Esquema del “Semáforo_V3”

AMBAR2 S1

E10 PASAR

VERDE2 S2

En el programa se distingue claramente qué instrucciones se ejecutan si NO se pulsa E10 (else). Se enciende la luz roja y se apagan las otras dos. En el instante que se detecta la pulsación de E10 (if) se inicia la secuencia de funcionamiento.

4.- SENTENCIA FOR() En cuanto veamos esta sentencia, inmediatamente le buscarás utilidad en alguno de los programas que hemos visto anteriormente, con objeto de hacerlo más pequeño y eficiente. Se trata de una sentencia para realizar bucles controlados. Un bucle es un conjunto de instrucciones cuya ejecución se repetirá un número determinado de veces. Sintaxis: for(inicio; condición; modificador) { …. …. } inicio:

Es una expresión que permite cargar una variable con un valor inicial. Solo se ejecuta una vez, al principio del bucle.

condición:

Es una expresión condicional. Si se cumple la condición (true), se ejecutan todas las instrucciones o sentencias del bucle. Si no se cumple la condición (false), el bucle finaliza y la ejecución del programa sigue su curso. Esta expresión se evalúa cada vez que se repite el bucle.

modificador:

Es una expresión que permite modificar el valor de la variable con objeto de alcanzar la condición. Este modificador se ejecuta cada vez que se repite el bucle.

llaves:

Encierran, a modo de “bocadillo”, a todas las instrucciones que forman el bucle y que deben ejecutarse un número determinado de veces.

Ejemplo: for(byte N = 1; N < 5; N=N+1) { …. …. }

4-5


Una imagen vale más que mil palabras. Observa el diagrama de flujo de la figura 4-6. Se declara la variable “N”, de tipo byte, y se le carga con el valor inicial 1 (byte N = 1). Se evalúa y, si es menor que 5 (N < 5), se ejecutan todas las sentencias cerradas entre las llaves. El valor de la variable “N” se modifica automáticamente y, en este caso, se incrementa en una unidad (N = N + 1). Vuelve a repetirse la evaluación de la condición. Si es cierta se vuelven a ejecutar las sentencias y el proceso se repite hasta que la condición sea falsa. En el ejemplo de la figura, las sentencias encerradas entre las llaves se ejecutan 4 veces: mientras “N” sea menor de 5. Figura 4-6. Esquema de funcionamiento de un bucle for()

Para establecer el inicio, la condición y el modificador de cualquier bucle for(), se pueden emplear todo tipo de expresiones aritméticas, booleanas o lógicas y de comparación entre variables y/o constantes. Por ejemplo: int A = 5; for(byte N=A+3); N <= A*2+8; N=N+3) { …. } ¿Cuál es el valor inicial del bucle?…………………………….. ¿Y el valor final?………………………………………………… ¿En cuánto se incrementa cada vez?………………………… ¿Cuántas veces se repite el bucle?…………………………… 4-1 Operadores compuestos En ocasiones realizamos operaciones sencillas con una variable, cuyo resultado va a parar a esa misma variable. Para ello existen los llamados “operadores compuestos” que simplifican esas expresiones: Operador ++ -+= -= *= /=

Operación Incrementa una unidad Decrementa una unidad Suma Resta Producto División

Ejemplo X ++ Y -X += Y X -= 3 X *= Y X /= 5

Equivale a … X=X+1 Y=Y-1 X=X+Y X=X-3 X=X*Y X=X/5

Son muy utilizados en los modificadores de la sentencia for(): for(byte N=1; N<5; N++)

Figura 4-7. Baliza de señalización


Aquí tienes una versión muy mejorada del programa “Faro” del tema anterior, el programa “Faro_V2”. El funcionamiento de ambos programas es idéntico. Consiste en hacer una baliza que parpadea tres veces seguidas cada 1.5 segundos. En esta ocasión empleamos la sentencia for(). Si comparas este programa con su primera versión, observarás que hay una gran diferencia en su tamaño. Ocupa menos memoria y es por tanto más eficiente. Es un buen ejemplo básico de aplicación de la sentencia for().

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Monta el circuito según el esquema de la figura 4-7. Se trata de un simple led, el S0, conectado con la línea D2 del controlador.

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

4-2 Ejemplo: Faro_V2

S0

4-6


4-3 Ejemplo: “Semáforo_V4” Ya tenemos la última y definitiva versión del ejemplo del semáforo, el “Semáforo_V4”. Su circuito es el mismo que el del esquema de la figura 4-5, y tiene idéntico funcionamiento que el ejemplo “Semáforo_V3”. Si comparas ambos observarás que el empleo de la función for() reduce notablemente el tamaño del programa, ocupa menos memoria del controlador y es por tanto más eficiente. 4-4 Ejemplo: “Ráfagas”


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

Se trata de emitir dos ráfagas luminosas sobre los leds S1 y S0 conectados con las señales D3 y D4 respectivamente. La secuencia se inicia al pulsar E10 conectado con la línea D2 del controlador. Ver el esquema de la figura 4-8. Cada vez que se produce una ráfaga de 5 destellos en el led S1, se produce un destello en el led S0. La secuencia finaliza cuando se hayan producido 6 de estos destellos en S1.

S0

E10 INICIO

S1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Los bucles for() se pueden anidar. Esto es, dentro de un bucle for() puede haber uno o más bucles for(), y dentro de cada uno de estos, puede haber otros y así sucesivamente. Este programa es una pequeña demostración de anidamiento de dos bucles.

Figura 4-8. Circuito del programa “Ráfagas” Observa el cuerpo principal del programa.

void loop() { if(!digitalRead(2)) { for(byte A=1; A<=6;A++) { for(byte B=1;B<=5;B++) { digitalWrite(3,HIGH); delay(80); digitalWrite(3,LOW); delay(100); } digitalWrite(4,HIGH); delay(100); digitalWrite(4,LOW); delay(120); } } }

//Si la entrada D2 es verdad (nivel "0") ... //Mientras A <= 6 //Mientras B <= 5 ... //Activa el led S1 //Temporiza //Desactiva el led S1 //Temporiza //Activa el led S0 //Temporiza //Desactiva el led S0 //Temporiza

Dentro de la función if(), si se cumple que la entrada D2 está a activada (“0”), se encuentran dos bucles for(). El más interno se controla desde la variable “B” que evoluciona desde 1 hasta 5. Produce una ráfaga de 5 destellos en el led S1 conectado a la línea D3. El bucle for() externo se controla mediante la variable “A” que evoluciona desde 1 hasta 6. Envuelve al bucle for() interno, por lo que este se repite 6 veces. Por cada una de ellas el led S0 conectado en la línea D4 produce un destello.

4-7


Cuando se anidan dos o más bucles for(), se resuelve primero el más interno siguiendo en orden hasta resolver, por último, el bucle más externo. 5.- SENTENCIA WHILE() Es una variante de la sentencia for(), y también se emplea para realizar bucles en donde un conjunto de instrucciones se ejecutan un número determinado de veces. Sintaxis: while (condición) { …. …. } condición:

Es una expresión condicional. Mientras la condición sea cierta (true) se ejecutan las sentencias del bucle. En caso contrario el bucle finaliza.

llaves:

Encierran a todas las sentencias que forman el bucle y que se ejecutarán siempre que la condición sea cierta (true). Si únicamente se debe ejecutar una instrucción, no es necesario cerrarla entre llaves. Si la sentencia while() finaliza con “;” se ejecuta así misma mientras se dé la condición.

5-1 Ejemplo: “Timbre_V2” Vamos a emplear el mismo circuito que el mostrado en el esquema de la figura 4-2. El cuerpo principal del programa se muestra a continuación: void loop() { while(digitalRead(2)); while(! digitalRead(2)); tone(12,400); delay(300); tone(12,300,300); }

//Esperar mientras D2=1 //Esperar mientras D2=0 //Genera una frecuencia de 400Hz... //... durante 0.3" //Genera una frecuencia de 300Hz durante 0.3"

Ambas funciones while() finalizan con “;”. La primera se ejecuta constantemente mientras la entrada D2 esté a nivel “1” (pulsador S0 sin accionar). La segunda while() se ejecuta constantemente mientras la entrada D2 esté a nivel “0” (pulsador S0 accionado). En otras palabras, el programa espera a que accionemos el pulsador (nivel “0”) y luego lo soltemos (nivel “1”), para ejecutar el tono de nuestro timbre. Hay que hacer ambas cosas: pulsar y soltar. Conviene recordar que los pulsadores del laboratorio Universal Trainer trabajan con lógica invertida. Si no se accionan ofrecen un nivel “1””. Cuando se accionan ofrecen un nivel “0”. 5-2 Ejemplo: “Contador” Un ejemplo práctico. Deseamos un sistema que cuente un número de piezas, por ejemplo 10, y genere una señal sonora de aviso. El pulsador E10 del laboratorio simula a un sensor que detecta las piezas, se conecta con la línea de entrada D2. El altavoz se conecta con la salida D12 y emite un tono de 1KHz durante 1 segundo cada vez que se detecta el paso de las 10 piezas (10 pulsaciones en E10). Se emplea por tanto el mismo esquema de montaje que el mostrado en la figura 4-2.

4-8


Void loop() { byte Contador=1; while (Contador <=10) { while(digitalRead(2)); while(!digitalRead(2)); Contador++; }

//Contador =1 //Mientras el contador no llegue a 10 ... //Esperar mientras D2 vale "1" //Esperar mientras D2 vale "0" //Pulso recibido, Contador+1

//Se han recibido los 10 impulsos. Se genera la señal acústica tone(12,1000,1000); //Tono de 1Khz durante 1 segundo } Se inicia la variable “Contador” con el valor 1. Mientras dicha variable sea menor de 10, se ejecuta un bucle while() formado por tres instrucciones. La primera de ellas espera mientras la entrada D2 (pulsador E10) esté a nivel “1”. La segunda espera mientras la entrada D2 esté a “0”. Cuando se haya cumplido ambas condiciones (el pulsador se accione y se suelte), se ejecuta la tercera instrucción: incrementar la variable “Contador” en una unidad. Cuando la variable “Contador” alcance el valor 10, el bucle finaliza y se ejecuta la instrucción tone(). 5-3 Ejemplo: “Contador_V2” Quizá hayas observado en el ejemplo anterior que en ocasiones, en lugar de contar 10 impulsos, cuenta menos. No es que el programa esté mal diseñado, es un problema debido al conocido “efecto rebote” típico de los dispositivos electromecánicos como son los pulsadores e interruptores. Estos dispositivos se basan en una laminilla metálica que conecta o no dos terminales eléctricos. Cada vez que se accionan es posible que esa laminilla rebote sobre los terminales durante un cierto tiempo hasta que se estabilizan. Realmente se pueden producir varios pulsos. Mira la figura 4-9. Aunque realicemos una única pulsación, la señal eléctrica que aplicamos al controlador está formada por varios pulsos. El tiempo que tarda en estabilizarse la laminilla del pulsador depende de la calidad del mismo y puede cifrarse en unos cuantos milisegundos. A pesar de ello, como nuestro Arduino es mucho más rápido, y detecta todos esos pulsos. Es decir, una única pulsación por parte nuestra puede ser interpretada como uno, dos o más pulsos por parte de Arduino.

Figura 4-9. El efecto rebote Una forma de evitarlos es intercalar una pequeña temporización. Observa la modificación que hemos hecho en el ejemplo “Contador_V2”. while(digitalRead(2)); delay(50); while(!digitalRead(2)); delay(50);

//Esperar mientras D2 vale "1" //Temporiza 50mS (anti rebotes) //Esperar mientras D2 vale "0" //Temporiza 50mS (anti rebotes)

Cuando se detecta un cambio de estado en el pulsador, se temporiza 50mS antes de esperar al siguiente cambio de estado. Se evitan así los rebotes que pudiera haber durante ese lapsus de tiempo.

4-9


6.- SENTENCIA SWITCH() / CASE Al igual que la sentencia if(), la sentencia switch() controla el flujo de un programa haciendo que se ejecuten unas instrucciones u otras en función de determinadas condiciones. En el caso de la sentencia switch() se compara el valor de una variable con el valor indicado en múltiples sentencias “case”. Cuando coincide con una de ellas, se ejecutan las instrucciones correspondientes. La palabra clave “break” finaliza la sentencia switch() y normalmente se usa al final de cada caso o “case”. Sintaxis: switch(var) { case 1: …. …. break; case n: ….. break; default: …. } var:

Es la variable cuyo contenido se va a comparar con los valores indicados en los diferentes “case”. Establecen todos los valores (1-n) con los que se va a comparar el contenido de la variable “var”. Cuando coincide con uno de ellos, se ejecutan todas las instrucciones comprendidas entre ese “case” y la expresión “break”. Es opcional. Si se usa, en caso de que no haya ninguna “case” que coincida con el valor de la variable “var”, se ejecutan todas sus instrucciones.

case:

default:

6-1 Ejemplo “Decodificador” El “decodificador” es un circuito muy empleado en sistemas de control digital. Básicamente se trata de un circuito que a partir de un código binario de entrada, genera un código binario de salida. En nuestro caso se trata de un decodificador de 2 x 4 (2 entradas y 4 salidas). Realiza el montaje correspondiente al esquema de la figura 4-10. Emplea dos interruptores, E1:E0 conectados con las líneas D9:D8 respectivamente. Con ellos podemos generar 4 combinaciones 2 posibles de entrada en nuestro decodificador (2 ).


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

Los leds S3:S0 del laboratorio se conectan con las líneas D3:D0 que se configuran como salidas. Su valor dependerá de las entradas de acuerdo a la siguiente tabla de la verdad: ENTRADAS SALIDAS E1 E0 S3 S2 S1 S0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 0 1 1 0 1 0 1

S3

S2

S0

S1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

E1 E0

Figura 4-10. Decodificador de 2 x 4

4 - 10


Echemos un vistazo al programa “Decodificador”. void loop() { A = PINB & B00000011; switch(A) { case 0: PORTD = 0; break; case 1: PORTD = B00001111; break; case 2: PORTD = B00001010; break; default: PORTD = B00000101; } }

//Lee el valor de E1 y E0

//Si vale 00 (0) //Saca 0000 //Si vale 01 (1) //Saca 1111 //Si vale 10 (2) //Saca 1010 //Entonces vale 11 (3) //Saca 0101

Se lee el Puerto B (PINB) y se hace la función AND con los dos bits de menos peso (& B00000011). El valor que se deposita en la variable “A” solo puede ser 00 (0), o 01 (1), o 10 (2) o bien 11 (3). La función switch(A) compara la variable con los posibles casos expuestos (case). Si es 0, por el Puerto D se saca el valor 0 (PORTD = 0,); si es 1, se saca el valor 1111; si es 2, se saca el valor 1010 y, por último, si no es ninguno de esos tres, por defecto se saca el valor 0101. 6.1.1 Trabajo personal Un tipo de decodificador muy empleado es el llamado “decodificador selector”. Por cada código de entrada solo se debe activar una y solo una salida. Responde a la siguiente tabla de la verdad: ENTRADAS E1 E0 0 0 0 1 1 0 1 1

S3 0 0 0 1

SALIDAS S2 S1 0 0 0 1 1 0 0 0

S0 1 0 0 0

Modifica el programa anterior para resolver este caso. 6-2 Ejemplo: “Juego de luces_V3” Con el mismo esquema de la figura 4-10 anterior, este ejemplo propone realizar cuatro juegos diferentes de luces. Cada juego se selecciona mediante los dos interruptores E1:E0 conectados a las líneas D9:D8 de entrada. El programa se presta a muchas modificaciones: échale imaginación. Puedes modificar los tiempos y las secuencias. Incluso puedes emplear más señales de entrada y salida para realizar secuencias más complejas y llamativas.

4 - 11


6-3 Ejemplo: “Decodificador BCD 7 segmentos” Hablando de decodificadores, otro muy utilizado en los circuitos digitales es el llamado “BCD a 7 segmentos”. Se trata de un circuito capaz de controlar el clásico dígito numérico o display como el mostrado en la figura 4-11. Un display de 7 segmentos consiste en un conjunto de 8 diodos led distribuidos estratégicamente y llamados a, b, c, d, e, f, g y dp (punto decimal). Según qué diodos se iluminen, podemos representar cualquier número y también algunas letras y símbolos. En el entrenador Universal Trainer disponemos de tres displays idénticos llamados de “ánodo común” (AC). El ánodo es común a todos sus leds y se conecta con la tensión positiva de alimentación (o a nivel “1”). El control individual de cada segmento o led se realiza aplicando un nivel lógico “0” a su respectivo cátodo. En nuestro ejemplo esos cátodos los vamos a conectar a las líneas D7:D0 del Puerto D del controlador Arduino NANO.

Figura 4-11. El display de ánodo común Basta con sacar por ese Puerto D las combinaciones binarias que iluminen los leds necesarios para representar un número, letra o símbolo. La siguiente tabla representa las combinaciones binarias que han de aplicarse para visualizar los número 0 al 9 y las letras A a la F, suponiendo que el punto decimal (dp) está desactivado. Recordemos que los leds del display de la Universal Trainer se activan al aplicarles un nivel “0”. ENTRADAS DIGITO BIN. DEC. 0 1 2 3 4 5 6 7 8 9 A B C D E F

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

D7 (dp) 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

D6 (g) 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0

D5 (f) 0 1 1 1 0 0 0 1 0 0 0 0 0 1 0 0

D4 (e) 0 1 0 1 1 1 0 1 0 1 0 0 0 0 0 0

D3 (d) 0 1 0 0 1 0 0 1 0 1 1 0 0 0 0 1

SALIDAS D2 D1 (c) (b) 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 1

D0 HEX. DEC. (a) 0 0xC0 192 1 0xF9 249 0 0xA4 164 0 0xB0 176 1 0x99 153 0 0x92 146 0 0x82 130 0 0xF8 248 0 0x80 128 0 0x98 152 0 0x88 136 1 0x83 131 0 0xC6 198 1 0xA1 161 0 0x86 134 0 0x8E 142

Monta el circuito de la figura 4-12. De los tres displays disponibles en el entrenador Universal Trainer, vamos a emplear el de la derecha. Representa a las unidades y se identifica como dígito AC3. Como es de ánodo común, su patilla AC3 se conecta con +5Vcc de alimentación. Los 7 segmentos (a-g) y el punto decimal (dp) se conectan con las líneas D0-D7 del Puerto D, que se configuran como salidas. Los interruptores E3:E0 se conectan con las líneas D11:D8 del Puerto B que se configuran como entradas. Mediante esos interruptores se introducen los códigos binarios para cada dígito o símbolo que queremos visualizar.

4 - 12



11 7 4 2 1 10 5 3

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

AC3

a b c d e f g dp

E3

8

AC2 9

12

AC1

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

E2 E1 +5Vcc

E0

Figura 4-12. Esquema del decodificador BCD a 7 segmentos ¡IMPORTANTE! Las líneas D0 y D1 del controlador Arduino NANO también se emplean como señales Rx y Tx durante la transferencia o carga de un programa. Se recomienda conectarlas a los segmentos del display una vez que se haya grabado el programa. El programa “Decodificador_BCD_7_segmentos” resuelve los requisitos de la tabla anterior, mediante el empleo de la sentencia switch() / case que estamos estudiando en estos momentos. Aunque más largo, su funcionamiento es muy similar al de los dos ejemplos anteriores. Leemos el estado de los cuatro interruptores 4 E3:E0. Estos nos proporcionan un número comprendido entre 0 y 15 (2 ). Mediante switch(A) / case se determina cuál es y por el Puerto D se saca la combinación binaria necesaria según la tabla anterior, para que se iluminen los segmentos apropiados del display. void loop() { A = PINB & B00001111; switch(A) { case 0: PORTD = B11000000; break; case 1: PORTD = B11111001; break; ….. …..

//Lee el valor de E3:E0

//Si vale 0000 (0) //Saca 11000000 //Si vale 0001 (1) //Saca 11111001

El ejemplo sin embargo, no es un programa realmente eficiente. Lo hemos resuelto con las funciones switch() / case porque es lo que tocaba. También se puede resolver mediante el empleo de “Arrays” como se estudió en el tema anterior. Echa un vistazo al ejemplo “Decodificador_BCD_7_segmentos_V2” que proponemos. En primer lugar se crea un Array de tipo byte llamado “Display”. Contiene, en decimal, los 16 valores posibles que hay que sacar a los segmentos. Para obtener cualquiera de ellos basta con indicar en qué posición dentro del Array se encuentra. Por ejemplo, Display[4] contiene el valor 153, que es precisamente al valor que hay que sacar a los segmentos para que visualicen el dígito 4. byte Display[16]={192,249,164,176,153,146,130,248, 128,152,136,131,198,161,134,142};

//Valores de salida

4 - 13


El programa principal es muy sencillo: void loop() { A = PINB & B00001111; PORTD = Display[A]; }

//Lee el valor de E3:E0 //Saca el valor de salida

Se lee el valor que proporcionan los interruptores de entrada E3:E0. Este valor estará comprendido entre 0 y 15 y se emplea como índice del Array para obtener el valor de salida (PORTD=Display[A]). ¡Qué diferencia de programa! La conclusión que debes de sacar de todo esto es que un mismo programa se puede resolver de varias formas diferentes. El lenguaje Arduino nos proporciona las sentencias y recursos necesarios para que, usados debidamente, podamos hacer programas muy eficientes. Es cuestión de tiempo y práctica. 6.3.1 Trabajo personal Completa la siguiente tabla con objeto de visualizar en el display ciertos símbolos y/o letras que tú mismo vas a diseñar. Luego modificas adecuadamente el programa para visualizarlos en función del valor que introduces con los interruptores de entrada. ENTRADAS SIMBOLO BIN. DEC. = “ º P r t u g H i J L n ñ o

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

SALIDAS D7 D6 D5 D4 D3 D2 D1 D0 HEX. (dp) (g) (f) (e) (d) (c) (b) (a)

DEC.

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

6-4 Ejemplo: “Década” Otro programa de carácter eminentemente práctico. Se trata de un dispositivo digital capaz de contar, de 0 a 9, el número de pulsos que se le aplican. Recibe el nombre de “Década” y su esquema de montaje se muestra en la figura 4-13. Los segmentos del display se conectan con las líneas D0:D7 del controlador, como en el ejemplo anterior. El display visualizará el número de pulsos aplicados. El pulsador E10 del entrenador Universal Trainer se conecta con la línea D8 que actúa como entrada. Con este pulsador vamos introduciendo los pulsos a contar.

4 - 14



11 7 4 2 1 10 5 3

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

AC3

a b c d e f g dp

8

AC2 9

12

AC1

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

E10 +5Vcc

Figura 4-13. Esquema de la década La fotografía de la figura 4-14 muestra el montaje práctico. 6.4.1 Trabajo personal Una vez que grabes y pruebes el programa, puedes usar el generador lógico del entrenador, para aplicar los pulsos a contar en lugar del pulsador. Para empezar retiras la conexión del pulsador E10 y conectas la patilla D8 con la salida del generador. Modifica el programa y anula las dos funciones delay() que eliminaban los rebotes. El generador está libre de ellos. Vuelve a grabar el programa recién modificado. A continuación selecciona una muy baja frecuencia de onda cuadrada, por ejemplo 1Hz. Verás cómo la cuenta avanza automáticamente desde 0 hasta 9 y empieza de nuevo con 0. Aumenta la frecuencia del generador. La cuenta será cada vez más rápida. Si sigues aumentando la frecuencia de conteo, llegará un momento en que se visualizará el número 8 con los 7 segmentos iluminados. Esto es debido a la ya mencionada “sensación óptica” que provoca la retina de nuestros ojos.

Figura 4-14. Montaje práctico de la década

6-5 Ejemplo: “Dado_Electrónico” Un ejemplo de carácter lúdico. Se trata de emular un dado electrónico que visualice sobre el display un número aleatorio entre 1 y 6. Aprovechamos la ocasión para estudiar dos nuevas funciones del lenguaje Arduino. Función random() Genera y nos devuelve un número aleatorio de entre una gran secuencia de números. Sintaxis: random(min,max)

4 - 15


min:

Establece el valor mínimo del número aleatorio que nos va a devolver. Es opcional. Si no se indica el valor mínimo será 0.

max:

Establece el valor máximo del número aleatorio.

Ejemplo: A = random (1,6);

//Devuelve un número aleatorio comprendido entre 1 y 6

Función randomSeed() El sistema que emplea Arduino para generar número aleatorios, consiste en una secuencia muy larga de números diferentes, pero siempre es la misma secuencia. Los números son por tanto “pseudo-aleatorios”. Con el empleo de esta sentencia se inicia internamente el sistema generador, haciéndole empezar en un punto arbitrario de la secuencia. Sintaxis: randomSeed(int o long) int o long:

Es un valor cualquiera, bien sea entero (16 bits), o entero largo (32 bits). Se emplea como “semilla” con la que se inicia el sistema generador de números aleatorios.

Ejemplo: randomSeed(33);

//La semilla para una nueva generación de números es 33

Monta el circuito según el esquema de la figura 4-13 anterior. Una vez que cargues el programa, comprueba su funcionamiento. Inicialmente el display aparece apagado con el punto decimal (dp) iluminado. Está a la espera de recibir un pulso por D8, e iniciar la jugada. Se obtiene un número comprendido entre 1 y 6 que se visualiza sobre el display durante 2 segundos. Luego este se apaga y comienza una nueva partida.

7.- OTRAS SENTENCIAS DE CONTROL Hemos visto las sentencias o funciones de control más importantes y utilizadas. De todas formas el lenguaje Arduino dispone de alguna más. Su empleo queda a criterio del programador.

7-1 Función do … while() Esta sentencia es muy similar a la sentencia while() ya estudiada. La diferencia es que la condición para repetir o no el bucle se establece al final del mismo, no al principio. Sintaxis: do { … … } while(condición); condición:

Es una expresión condicional. Mientras la condición sea cierta (true) se ejecutan las sentencias del bucle, las comprendidas entre do y while(). En caso contrario el bucle finaliza.

4 - 16


llaves:

Encierran a todas las sentencias que forman el bucle y que se ejecutarán un determinado número de veces mientras la condición sea cierta (true).

7-2 Función break Esta función es una forma de finalizar o “romper” cualquier bucle fo(), while() o do…while() aunque no se dé la condición establecida. También la hemos usado para salir o finalizar la función switch() / case. Sintaxis: break;

7-3 Función return Retorna o finaliza cualquier función creada por el usuario. Si se desea puede devolver un valor al programa que hizo uso o llamó a esa función. Sintaxis: return rteturn valor; valor:

Es el valor que devuelve la función en su retorno. Es opcional y puede ser una variable o una constante.

7-4 Función goto Traslada, de forma incondicional, la ejecución al punto del programa indicado. Sintaxis: prueba: … … … goto prueba;

//Salta incondicionalmente al punto del programa en el que se encuentre la etiqueta indicada.

4 - 17


4 - 18

ARDUINO: La tecnología al alcance de todos TEMA 5: Las señales PWM y el control de servo motores www.microcontroladores.com

TEMA 5: Las señales PWM y el control de servos 1.- INTRODUCCIÓN En el Tema 1 se explicó que algunas de las 14 patillas de entrada o salida digitales que dispone la tarjeta Arduino NANO, podían actuar como salidas de señales del tipo PWM. Concretamente son 6 patillas: D3, D5, D6, D9, D10 y D11. Consulta la figura 1-9. La abreviatura “PWM” viene de “Pulse Width Modulation” o, lo que es lo mismo, “Modulación de anchura del pulso”. Se trata de una señal periódica de una determinada frecuencia F pero asimétrica: la duración del semiperiodo positivo (el nivel “1”), es diferente a la duración del nivel “0”, y además se puede variar dentro de los límites de la duración del periodo T. La figura 5-1 muestra un ejemplo de señal de onda cuadrada con una frecuencia de F de 500 Hz. Su periodo T tiene una duración de 2 mS (T=1/F). En este caso el nivel “1” de la señal dura 1 mS, lo mismo que el nivel “0”. Se trata por tanto de una señal simétrica. El tiempo en que la señal vale “1” se le denomina “ciclo útil”. En el ejemplo de la figura su valor es del 50% (1 mS) respecto al valor total del periodo (2 mS). Se dice que es una señal PWM al 50 %. Figura 5-1. Señal PWM al 50% La figura 5-2 muestra una secuencia de cuatro señales PWM: A, B, C y D. Todas tienen en común el mismo periodo T de 2 mS o, lo que es lo mismo, una frecuencia de 500 Hz. Sin embargo la duración del nivel “1”, es decir del ciclo útil, varía.

Figura 5-2. Señales PWM La señal A tiene un ciclo útil del 0%. Durante la duración total del periodo T, los 2 mS, la señal permanece a nivel “0”. La señal B se corresponde con una señal PWM cuyo ciclo útil es del 25% de la duración del periodo. Esto es, el nivel “1” se mantiene durante 0.5 mS y el nivel “0” los 1.5 mS restantes del periodo (75%).

5-1


La señal C representa una señal PWM cuyo ciclo útil es el 75% de la duración total del periodo. El nivel “1” dura 1.5 mS y el nivel “0” los 0.5 mS restantes (25%). Por último, la señal D representa a una señal cuyo ciclo útil es del 100% de la duración del periodo. El nivel “1” dura los mismos 2 mS. La mayor parte de los controladores actuales, entre los que se encuentra nuestro Arduino NANO, integran la electrónica necesaria para generar, si se desea, una o varias señales PWM por algunas de sus patillas. En nuestro caso esas patillas son: D3, D5, D6, D9, D10 y D11. Cuando se habilitan, la frecuencia F de las señales es fija. Para las patillas D5 y D6 es aproximadamente de 980 Hz (T=1mS) y de 490 Hz (T=2 mS) para el resto. 1-1 ¿Para qué sirven las señales? Las señales PWM se pueden usar para controlar y regular la potencia que aplicamos a ciertos periféricos de salida como puede ser un led, un motor, un servo, etc…, ya que podemos ajustar la duración o el tiempo en que se mantiene el nivel “1” (ciclo útil), en cada periodo. Imagina una señal PWM aplicada a un led. Si el ciclo útil fuera del 100% (figura 5-2-D), al led le estaríamos aplicando un nivel “1” constantemente. Brillará a la máxima potencia. Si la señal PWM aplicada fuera del 50%, como se muestra en la figura 5-3, la mitad del tiempo estaría encendido y la otra mitad apagado. El led brillará a la mitad de su potencia. Figura 5-3. Señal PWM al 50% Según este razonamiento, si se le aplica una señal con un ciclo útil del 25% (figura 5-2-B), el led brillará la ¼ parte de su potencia. Si la señal fuera del 75% (figura 5-2-C), brillará las ¾ partes de su potencia. Con una señal PWM del 0% (figura 5-2-A), el led se apagará. Tenemos por tanto un rango que va del 0% hasta el 100% de la señal PWM para ajustar el brillo deseado. De la misma manera que podemos regular el brillo de un led o de una lámpara, también podemos regular la velocidad a la que gira un motor o el posicionamiento de un servo. El principio es el mismo. 1-2 Función analogWrite() Permite determinar la duración de la anchura del pulso o el ciclo útil de una señal PWM de salida. Sintaxis: analogWrite(pin,valor) pin:

Es la patilla por donde se va a generar la señal PWM. En el controlador Arduino NANO puede ser 3, 5, 6, 9, 10 u 11.

valor:

Es el valor que determina la duración del ciclo útil. Está comprendido entre 0 y 255, donde 0 corresponde con un ciclo útil del 0% de duración, y 255 con un ciclo útil del 100%.

Ejemplo: analogWrite(6,127);

//Salida de una señal PWM del 50% sobre la patilla 6

La patilla elegida para sacar la señal PWM no necesita ser configurada como salida. La propia función analogWrite() lo hace automáticamente. La señal PWM de salida se mantiene indefinidamente hasta que indiquemos un ciclo útil de valor diferente o bien se ejecute una función del tipo digitalRead() o digitalWrite() sobre esa misma patilla. En este caso la salida de señal PWM se anula.

5-2


2.- USANDO LAS SEÑALES PWM

Es el ejemplo más sencillo que se puede realizar. Monta el circuito mostrado en el esquema de la figura 5-4. El led S0 del entrenador Universal Trainer se conecta con la patilla D6 del controlador Arduino NANO. Esta patilla se empleará como salida PWM y nos permitirá controlar la potencia que se aplica al led, regulando así su brillo.

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 D1 VIN D0 GND RESET RESET GND +5V D2 A7 D3 A6 D4 A5 D5 A4 D6 A3 D7 A2 D8 A1 D9 A0 D10 AREF D11 3V3 D12 D13

2-1 Ejemplo: PWM

+5Vcc

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Vamos a realizar una serie de ejemplos que permitan sacar una o varias señales PWM por algunas de las patillas disponibles al efecto: D3, D5, D6, D9, D10 y D11.

Figura 5-4. Señal PWM

S0

Echemos un vistazo al programa. Empieza declarando dos variables. En la variable “Potencia” indicamos la potencia que deseamos, o lo que es igual, la duración del ciclo útil. En el ejemplo es del 25%. En la variable “Ciclo” se almacena un valor comprendido entre 0 y 255, calculado a partir de la potencia indicada. byte Potencia=25; int Ciclo=(Potencia*255)/100;

//Expresar aquí el % de la potencia deseada //Calcula el ciclo útil entre 0 y 255

La función void setup() está vacía. En este caso no vamos a configurar nada, pero es obligatorio poner la función. El programa principal es muy sencillo. La sentencia analogWrite() configura a la patilla D6 como salida y genera por ella una señal PWM cuyo valor depende de la variable “Ciclo” que, a su vez, se obtiene a partir de la variable “Potencia”. Luego el programa queda en un bucle infinito mediante la función while(1);. void loop() { analogWrite(6,Ciclo); while(1); }

//Genera la señal PWM //Bucle sin fin

Al cargar el programa y ejecutarlo, veremos que el led S0 brilla bastante menos que como lo ha venido haciendo en ejemplos anteriores. Puedes probar a modificar el programa variando el valor de la potencia deseada. 2-2 Ejemplo: Efectos Con este programa de ejemplo sí que podrás apreciar claramente el efecto de “regulación” del brillo de un led, al que se le aplica una señal PWM variable. Emplea el mismo esquema de conexiones que el de la figura 5-4. Efectivamente, mediante un bucle for() el ciclo útil de la señal PWM va creciendo desde un mínimo (0) hasta un máximo (255) en pasos de 5 en 5. for(int Ciclo=0; Ciclo <=255; Ciclo +=5) { analogWrite(6, Ciclo); delay(40); }

//Desde 0 a 255 en pasos de 5 en 5 //Señal PWM con un ciclo útil que va aumentando //Temporiza 40 mS entre incrementos

5-3


La variable “Ciclo” empieza con 0 y evoluciona hasta llegara a 255 en incrementos de +5 (0, 5, 10, 15,…). Los distintos valores de esta variable se emplean para generar una señal PWM cuyo ciclo útil va aumentando hasta llegar al 100% (255). El brillo del led irá aumentando. Luego, mediante otro bucle for() y de forma parecida, la señal va decreciendo desde un máximo (255) hasta un mínimo (0) en iguales pasos. El brillo del led irá disminuyendo. 2-3 Ejemplo: Luces_Aleatorias


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

Monta el circuito del esquema de la figura 5-5. Consiste en un vistoso juego de luces en el que los leds S0-S3 lucen con un brillo aleatorio. Estos leds se conectan con las patillas D6, D9, D10 y D11 que, como ya sabemos, pueden actuar como salidas de señales PWM.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

S3 S2 S1 S0

La importancia de este ejemplo radica en que se demuestra que el controlador es capaz de generar cuatro señales PWM simultáneas y diferentes. No olvides que puede generar hasta seis señales PWM. Mediante la ya conocida función random() se generan cuatro números aleatorios comprendidos entre 0 y 255. Cada número se emplea para determinar el ciclo útil de cada una de las señales PWM de salida que van a parar a sus correspondientes leds. Figura 5-5. Luces_Aleatorias +5Vcc

2-4 Ejemplo: Regulación


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Otro ejemplo de carácter práctico. En esta ocasión vamos a ajustar manualmente el ciclo útil de una señal PWM que regula el brillo de un led. Monta el circuito de la figura 5-6.

ARDUINO NANO

Figura 5-6. Regulación manual

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

El led S0 se conecta con la patilla D6 desde donde se le aplica la señal PWM. La patilla D2 se conecta con el pulsador E10. Con cada pulsación, la señal PWM en D6, va aumentando de 10 en 10 hasta un máximo de 250 (máximo brillo). La patilla D3 se conecta con el pulsador E11. Con cada pulsación la señal PWM va disminuyendo de 10 en 10 hasta llegar a 0 (mínimo brillo). AUMENTA

E10

DISMINUY E

E11 S0

3.- SERVOMOTORES Los servomotores, también conocidos como “servos”, son dispositivos similares a un motor de corriente continua (DC) pero con la capacidad de realizar giros de forma controlada a cualquier posición y en cualquier sentido, dentro de su rango de acción. Por ejemplo, podemos indicar que su eje realice un giro de 34º en sentido horario, y se mantenga en esa posición indefinidamente hasta que se indique otra nueva. Su aspecto puede parecerse al que se muestra en la figura 5-7. Se utilizan con mucha frecuencia en sistemas de radio control como aviones teledirigidos, helicópteros, embarcaciones, vehículos, etc… También se emplean en robótica y, en general, en todas aquellas aplicaciones en que se necesite posicionar con precisión el eje de un motor.

Figura 5-7. Un servomotor

5-4


En la figura 5-8 se muestra su composición interna. Está formado por un motor DC, un grupo reductor y una electrónica de control. Todo ello va encapsulado en una caja con un eje que transmite el movimiento. El servo se controla aplicándole una señal PWM de unas determinadas características determinadas por su fabricante.

Figura 5-8. Composición interna de un servo

Desde el punto de vista de su conexión, la mayor parte de los servos precisan únicamente de tres cables como se muestra en la figura 5-9. El cable negro para la tensión GND o 0V de alimentación. Por el rojo se aplica una tensión de +5V. Por el blanco se aplica la señal PWM de control. Debes tener en cuenta que esto puede cambiar de un modelo a otro de servo. Lo ideal es consultar y cerciorarse mediante la documentación que facilita el fabricante.

Figura 5-9. Conexiones típicas de un servo Comercialmente podemos encontrar muchos tipos de servos. Se diferencian en el tamaño, fuerza o “par” motor, velocidad, tensión de alimentación, tipo de eje y, sobre todo, rotación del mismo. Hay servos cuyo eje es de rotación continua, y otros rotan o giran un número limitado de grados. Entre estos últimos, el más popular es el que cuyo eje es capaz de girar entre 0º y 180º. El control de un servo se realiza aplicándole, por la correspondiente patilla, una señal PWM cuyo ciclo útil determina la posición o rotación a la que se desplazará el eje. Aunque las especificaciones exactas las facilita el fabricante, más o menos todos funcionan de forma similar. La figura 5-10 puede ser un buen ejemplo. El periodo T de la señal es fijo, y suele ser en torno a los 20 mS (F=50 Hz). Un ciclo útil de 1,5 ms de duración, mantiene al servo centrado en 0º. Un ciclo útil de 1 mS hace que el servo gire 90º en un sentido. Entre 1 mS y 1.5 mS rotará la parte proporcional. Con un ciclo útil cuya anchura es de 2 mS, el servo rota otros 90º en sentido contrario. Un ciclo de entre 1,5 mS y 2 mS producirá una rotación proporcional. Figura 5-10. Señales PWM para el control de un servo

5-5


3-1 Conexión del servo Para nuestras prácticas y ejemplos vamos a usar el servo modelo S3003 de la firma Futaba, que se incluye en el presente módulo. Sus características fundamentales son:       

Velocidad: 0.23 seg./60º a 4.8V y 0.19 seg./60º a 6V Fuerza: 3.2 Kg/cm a 4.8V y 4.1 Kg/cm a 6V Dimensiones: 40 x 20 x 36 mm Peso: 36 gr Conector: Tipo “J” de 3 vías paso 2.54 mm Rotación: 0 – 180º Ciclo útil: 0.3 – 2.3 mS. Centrado a 1.3 mS. Periodo T=20 mS (F=50 Hz) Como se muestra en la figura 5-11, vamos a emplear una tira de pines macho. Esta tira, a la que cortaremos un trozo con tres pines, también se incluye en el lote de materiales del presente módulo. Por un lado estos tres pines se insertan en el conector hembra del servo, también de tres vías. Posteriormente podremos insertar todo el conjunto sobre el módulo board del entrenador Universal Trainer y hacer así las conexiones. Figura 5-11. La tira de pines

+5Vcc


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Servo 900-00008

Figura 5-12. Conexiones eléctricas

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

PWM 1

GND Vdd

ARDUINO NANO

3 2

En la figura 5-12 tenemos el esquema de conexiones que vamos a emplear en los próximos ejemplos. El servo únicamente necesita tres conexiones. El cable negro se conecta con GND de alimentación. El cable rojo se conecta con +5Vcc de alimentación. Mediante el cable blanco se le aplica la señal PWM que controla su posicionamiento o rotación. Lo vamos a conectar con la patilla D3 del controlador Arduino NANO.

+5Vcc

El montaje práctico se muestra en la figura 5-13.

Figura 5-13. Montaje práctico del servo

5-6


3-2 La librería servo El lenguaje Arduino, al igual que cualquier otro lenguaje, es algo vivo que con el paso del tiempo se va enriqueciendo incluyendo nuevas palabras y acepciones. En nuestro caso el lenguaje Arduino va adquiriendo nuevas funciones y sentencias. Cuando se añaden sentencias de propósito general, que no tienen una aplicación en concreto, estas se incluyen en el propio lenguaje, como si fuera una ampliación del mismo. Por eso es aconsejable que, periódicamente, descargues la última versión disponible. Sin embargo, si se crean nuevas sentencias para un fin específico, estas se suelen incluir en lo que se denomina una “librería”, que no es otra cosa que un fichero auxiliar con extensión “.h” que contiene el código necesario para implementarlas. Podemos encontrar librerías para el control de pantallas, robots, servos, comunicaciones, tarjetas de memoria, internet y mucho más. Algunas librerías están diseñadas por la propia organización de Arduino. Otras librerías las suministran los propios fabricantes de hardware y accesorios. En otros casos tú mismo puedes crear tus propias librerías para un determinado objetivo. En estos momentos nos vamos a centrar en la librería “Servo”. Se trata de un fichero, “Servo.h”, que se instala junto con el sistema Arduino. Una vez incluido en nuestro programa podemos pensar que nuestro lenguaje se ha enriquecido con las nuevas sentencias que incluye ese fichero. En el caso de “Servo.h” disponemos de seis nuevas funciones o sentencias relacionadas con el control de los servos. El hecho de usarlas nos facilitará notablemente el diseño de nuestros propios programas y aplicaciones. 3-2-1 #include Permite incluir en nuestro programa cualquiera de las librerías disponibles. Sintaxis: #include

Incluir la librería indicada.

Ejemplo: #include

Incluye en nuestro programa la librería “Servo”. Esto nos permite hacer uso de todas las funciones y sentencias que contiene y que veremos a continuación.

3-2-2 attach() Asocia un servo a cualquiera de las líneas digitales disponibles. A diferencia de las señales PWM, que únicamente estaban disponibles en seis de las patillas del controlador, las señales PWM para el control de servos se pueden generar por cualquier patilla. Son señales que se generan por software. Sintaxis: servo.attach(pin); servo.attach(pin,min,max); servo:

Es una variable tipo servo que asigna un nombre al servo que vamos a controlar (lo veremos enseguida). pin: Número de patilla a la que se conecta el servo. min (opcional): Establece, en micro segundos, la anchura mínima del pulso correspondiente a un ángulo de 0º. Por defecto es de 544. Revisar la documentación del fabricante. max (opcional): Establece, en micro segundos, la anchura máxima del pulso correspondiente a un ángulo de 180º. Por defecto es de 2400. Revisar la documentación del fabricante.

5-7


Ejemplo: #include Servo Mi_Servo; … Mi_Servo.attach(3);

//Incluir la librería “Servo” //Crea una variable tipo servo denominada “Mi_Servo” //Conecta “Mi_Servo” con la patilla D3

3-2-3 writeMicroseconds() Genera una señal PWM cuya anchura o ciclo útil, expresado en microsegundos, se aplica al servo indicado. Esta señal origina por tanto el desplazamiento del eje un determinado número de grados. Sintaxis: servo.writeMicroseconds(valor); servo: Variable del tipo servo. valor: Valor de tipo int que determina los microsegundos que dura el ciclo útil de la señal PWM generada. Ejemplo: Suponiendo el servo modelo S3003 de Futaba, como el que se incluye en este módulo de prácticas… #include Servo S3003; … S3003.attach(3); S3003.writeMicroseconds(300); delay(1000); S3003.writeMicroseconds(2300);

//Incluir la librería “Servo” //Crea una variable tipo servo denominada “S3003” //Conecta “S3003” con la patilla D3 //Ciclo útil de 0.3 mS (giro a un extremo, 0º) //Temporiza 1 segundo //Ciclo útil 2.3 mS (giro al extremo opuesto, 180º)

3-2-4 write() Genera una señal PWM cuya anchura o ciclo útil se obtiene a partir de los grados que indicamos en la propia función. Esta señal origina por tanto el desplazamiento del eje del servo un determinado número de grados. Sintaxis: servo.write (valor); servo: Variable del tipo servo. valor: Valor de tipo byte que determina los grados que se desplaza el eje (entre 0º y 180º). Ejemplo: Suponiendo el servo modelo S3003 de Futaba, como el que se incluye en este módulo de prácticas… #include Servo S3003; … S3003.attach(3,300,2300); S3003.write (0); delay(1000); S3003.write(180);

//Incluir la librería “Servo” //Crea una variable tipo servo denominada “S3003” //Conecta “S3003” con D3 y establece la anchura mínima y máxima //del ciclo útil de la señal PWM //Giro a un extremo (0º) //Temporiza 1 segundo //Giro al extremo opuesto (180º)

5-8


3-2-5 read() Lee el ángulo actual en el que se encuentra el servo, que no es otro que el valor que se le ha pasado en la última función write(). Sintaxis: servo.read(); servo: Variable de tipo servo. Ejemplo: #include Servo S3003; S3003.attach(3,300,2300); …. S3003.read();

//Incluir la librería “Servo” //Crea una variable tipo servo denominada “S3003” //Conecta “S3003” con D3 y establece la anchura mínima y máxima //Devuelve un valor de entre 0º y 180º que representa el ángulo en //que se encuentra actualmente el servo.

3-2-6 attached() Comprueba si un servo está o no asociado a una determinada patilla. Sintaxis: servo.attached(); servo: Variable de tipo servo Ejemplo: #include Servo S3003; S3003.attach(3,300,2300); …. S3003.attached()

//Incluir la librería “Servo” //Crea una variable tipo servo denominada “S3003” //Conecta “S3003” con D3 y establece la anchura mínima y máxima //Devuelve “true” ya que el servo está vinculado a D3

3-2-7 detach() Desconecta o desvincula la variable Servo de su correspondiente patilla. Cuando tenemos algún servo vinculado, las patillas D9 y D10 NO pueden usarse como salidas PWM. Si se desvinculan todas las variables Servo existentes, esas patillas SI pueden usarse como salidas PWM. Sintaxis: servo.detach(); servo: Variable de tipo servo Ejemplo: #include Servo S3003; S3003.attach(3); …. S3003.detach()

//Incluir la librería “Servo” //Crea una variable tipo servo denominada “S3003” //Conecta y vincula “S3003” con D3 //Desvincula el servo S3003 de la patilla D3

5-9


4.- USANDO LOS SERVOS Es el momento de proponer una serie de ejemplos que nos permitan aprender a usar un servo como el que se incluye en el lote de materiales del presente módulo de prácticas. Recuerda que los servos son periféricos con una gran cantidad de aplicaciones. Se utilizan en aquellos casos en que sea necesario controlar con cierta exactitud el posicionamiento del eje de un motor: el timón de una embarcación, la dirección de un vehículo, los alerones de un avión, el posicionamiento de un objeto, robótica, automatismos, y un largo etcétera. 4-1 Ejemplo: Servo Un buen ejemplo para tener una primera toma de contacto con un servo motor. Necesitas montar el esquema mostrado en la anterior figura 5-12, en la que el servo se controla mediante la patilla D3 del controlador Arduino NANO. El programa empieza incluyendo la librería “Servo.h” que contiene las funciones que usaremos posteriormente para controlar el servo. #include

//Incluir la librería Servo

A continuación se define la variable Servo a la que se le asigna el nombre “S3003”. Es el modelo de servo de la firma Futaba que estamos usando. Puedes emplear cualquier otro nombre, pero aquel pongas, será el que debes utilizar en lo sucesivo para cualquier operación que vayas a hacer con ese servo. También se crea la variable “pwm”. En ella introducimos, en micro segundos, la duración del ciclo útil de la señal PWM que se aplicará al servo. Según las especificaciones del modelo Futaba S3003, la duración mínima es de 300 µS y la máxima 2300 µS, lo que provoca desplazamientos del eje de un extremo al otro con un giro de 180º de recorrido en total. Servo S3003; int pwm=2300;

//Crea la variable S3003 (modelo de futaba) //Establece el ciclo útil (entre 300 y 2300 uS)

En la función de configuración indicamos, mediante la sentencia attach(), que el servo S3003 está conectado o vinculado con la patilla D3 del controlador. void setup() { S3003.attach(3); }

//Conecta el servo

Finalmente el programa principal, mediante la sentencia writeMicroseconds(), se limita a generar la señal PWM que controlará el servo S3003. La duración del ciclo útil depende del contenido de la variable “pwm”. void loop() { S3003.writeMicroseconds(pwm); while(1); }

//El servo se posiciona según "pwm" //Fin del programa

4-1-1 Trabajo personal Se puede calcular cuántos µS de ciclo útil son necesarios para girar 1º. En nuestro modelo Futaba S3003 será: ⁄º =

−

=

−

=

.

μ

5 - 10


Ahora será fácil determinar la duración que debe tener el ciclo útil de la señal PWM, para que el eje gire un determinado número de grados (g). =

−( ∗

.

)

Por ejemplo:   

Para girar 0º (un extremo del servo), PWM = 2300 – (0 * 11.11) = 2300 Para girar 90º (servo centrado), PWM = 2300 – (90 * 11.11) = 1300 Para girar 180º (el otro extremo del servo), PWM = 2300 – (180 * 11.11) = 300

Completa la siguiente tabla calculando los valores necesarios para realizar giros de diferentes grados. Luego modificas la variable “pwm” del programa para comprobar el correcto funcionamiento. ANGULO PWM

15º

30º

45º

75º

90º

105º

120º

135º

150º

165º

180º

4-2 Ejemplo: Servo_V2 Se trata de un ejemplo similar. En lugar de emplear la función writeMicroseconds() se emplea la función write() para generar la señal PWM que controlará el giro del servo. Dicha función write() tiene la ventaja de que podemos expresar el giro directamente en grados, por lo que no es necesario hacer los cálculos que hicimos en el ejemplo anterior. Es la propia función write() quien calcula la duración del ciclo útil de la señal PWM, a partir de los grados que deseamos girar. Ahora bien, para ello es necesario que conozca la duración mínima y máxima de ése ciclo útil, según el modelo de servo que estemos utilizando. Por este motivo, en la función attach() indicamos ahora estos dos parámetros: void setup() { S3003.attach(3,300,2300); }

//Conecta y ajusta el servo

Si no se indican, se toman por defecto los valores de 544 µS y 2400 µS para la duración mínima y máxima respectivamente. El efecto que esto puede producir es que el servo se vea excedido o limitado en su recorrido. 4-3 Ejemplo: Servo_V3 Este ejemplo es una consecuencia de todo lo visto hasta el momento. El servo realiza una maniobra consistente en desplazarse de un extremo al otro (180º en total) en intervalos de 5º. Luego vuelve a la posición inicial y el ciclo se repite constantemente. 4-4 Ejemplo: Servo_Control

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 D1 VIN D0 GND RESET RESET GND +5V D2 A7 D3 A6 D4 A5 D5 A4 D6 A3 D7 A2 D8 A1 D9 A0 D10 AREF D11 3V3 D12 D13 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

PWM 1

GND Vdd

ARDUINO NANO

3 2

Con un poco de imaginación quizá puedas entrever las posibilidades prácticas de este programa.

Servo 900-00008

Un buen ejemplo que te va a permitir interaccionar y controlar manualmente el posicionamiento del servo. Monta el esquema de la figura 5-14. Inicialmente el servo se mantiene centrado a 90º. Mediante los pulsadores E10 y E11, conectados con las patillas D4 y D5, vamos aumentando o disminuyendo el ángulo de giro en pasos o intervalos de 5º.

+5Vcc

DISMINUY E E11

Figura 5-14. Control manual de posicionamiento

AUMENTA +5Vcc

E10

5 - 11


5 - 12

ARDUINO: La tecnología al alcance de todos TEMA 6: Las comunicaciones www.microcontroladores.com

TEMA 6: Las comunicaciones 1.- INTRODUCCIÓN Entendemos por comunicar al hecho de compartir información. Entre los humanos podemos transmitir y recibir ideas, sensaciones, pensamientos, conocimientos, sentimientos, etc… En el mundo de los ordenadores en general y de Arduino en particular, también se puede compartir información. Un Arduino se puede comunicar con otro Arduino, con un ordenador tipo PC, con otro controlador, con un periférico, etc… Estamos hablando de transmitir y recibir datos numéricos. Imagina un Arduino que, bajo el control de tu programa, es capaz de recoger información del entorno que le rodea a través de sensores de luz, presión, temperatura, humedad, velocidad, posición, presencia, etc… Esta información se transmite, por ejemplo, a un PC. Este a su vez, bajo su propio programa de control, recoge la información recibida para manipularla, registrarla, visualizarla gráficamente, imprimirla y, en definitiva, realizar cualquier tipo de tratamiento con ella. De igual forma, te puedes imaginar a un PC transmitiendo a nuestro Artduino una serie de órdenes o instrucciones. Ordenes que al ser recibidas por nuestro Arduino, se procesan y se traducen en tareas tales como activar / desactivar una bombilla, un led, un motor, un servo, un relé, o cualquier cosa que sea necesario controlar. Ordenes con las que generar señales PWM, frecuencias de diferentes valores, realizar cálculos o iniciar diferentes procesos dentro de Arduino. En definitiva, las posibilidades de comunicar nuestro controlador Arduino NANO, abren una ventana con el mundo exterior. Arduino no se queda en una simple tarjeta electrónica que ejecuta una determinada tarea. Arduino es ahora capaz de “dialogar” con otros periféricos o sistemas, algunos de los cuales más grandes y potentes que él mismo, y compartir información. 2.- LA COMUNICACIÓN SERIE Al hablar de comunicar Arduino con cualquier otro sistema, estamos hablando de una comunicación digital donde los datos transferidos son siempre códigos binarios compuestos de bits. Es más, la cantidad mínima de información que se puede transferir es un byte que, como ya sabes, está compuesto de 8 bits. Las personas nos podemos comunicar de diferentes formas: oral, escrita o visual. De la misma manera, los sistemas digitales también tienen diferentes formas de trasferir información. Probablemente, una de las más extendidas y utilizadas, sea la comunicación “serie asíncrona”. Observa la figura 6-1.

Figura 6-1. La comunicación serie Es un tipo de comunicación que está disponible en cualquiera de las plataformas Arduino (UNO, NANO, MEGA, DUE, etc…). Se emplean únicamente dos patillas o líneas: transmisión de datos (Tx) y recepción de datos (Rx). Bajo el punto de vista del Arduino de la figura, éste transmite datos a través de la línea Tx y son recibidos por el PC a través de su línea Rx. También a la inversa. El PC transmite datos a través de su línea Tx, que son recogidos por la línea Rx de Arduino. Es decir, lo que es transmisión (Tx) en un extremo, es recepción (Rx) en el opuesto y viceversa.

6-1


Una transferencia de datos puede estar compuesta de decenas, cientos o miles de bytes. Un byte está compuesto de 8 bits que van “circulando” uno tras otro por las líneas Tx y/o Rx, dependiendo de quién trasmita o quién reciba. Según el tiempo “t” en que cada uno de esos bits se mantenga en la línea Tx o Rx, se determina la velocidad de la transferencia. Por ejemplo, si cada bit de cada byte se mantiene 1 segundo en las líneas Tx o Rx, se dice que la comunicación es de 1 bit por segundo. Esto recibe el nombre de “baudio”. Un byte completo tardará como mínimo 8 segundos en transferirse. Si lo multiplicas por el número total de bytes a transferir, obtienes el tiempo que tarda en realizarse la comunicación. Arduino es capaz de realizar comunicaciones desde los 300 hasta los 115200 baudios. Es decir, 115200 bits por segundo, o lo que es lo mismo, aproximadamente 14000 bytes por segundo (115200 / 8). En este caso, cada bit se transmite o recibe en tan solo 8.6 µS (1 / 115200). La velocidad a la que vamos a realizar las comunicaciones en los próximos programas de ejemplo, es de 9600 baudios. Se trata de una velocidad muy segura y fiable. La admiten la mayor parte de dispositivos con los que vayamos a comunicar, por ejemplo, un PC. 2-1 Tipos de comunicación serie Realmente Arduino, y la mayor parte de controladores, puede realizar diferentes tipos de comunicaciones serie, con objeto de poder compartir información con el mayor número de dispositivos posible: 

Comunicación asíncrona tipo UART Es la más utilizada y a ella nos vamos a referir en el presente tema. Su esquema responde a la figura 6-1 y se emplean dos señales para ello: Tx y Rx. Está pensada para la comunicación entre equipos, por ejemplo: Arduino-Arduino; Arduino-PC, Arduino-Periférico, etc..



Comunicación síncrona tipo I2C También es muy utilizada. Cada bit que se transmite o recibe va acompañado de un pulso de reloj o sincronismo. Emplea dos señales. La señal de datos (SDA) es por donde, bit a bit, se van transfiriendo o recibiendo los diferentes bytes de la información. La señal de reloj (SCL) genera un pulso de sincronismo por cada bit que se transfiere. Se emplea para la comunicación entre el controlador (p.e. Arduino) y otros circuitos integrados que lo acompañan.



Comunicación síncrona tipo SPI Emplea cuatro señales. Por la señal MOSI se reciben los bits y por la señal MISO se transmiten. La señal SCK es la señal de reloj por donde se genera un pulso por cada bit transmitido y/o recibido. Existe una cuarta señal, SS, que se suele emplear para seleccionar un dispositivo SPI en particular cuando conviven varios en el mismo circuito. También se emplea para la comunicación entre el controlador y otros circuitos integrados que lo puedan acompañar.

Sea cual sea el tipo de comunicación que vayamos a realizar, debemos conocer qué patillas de nuestro controlador Arduino NANO son empleadas por esas señales. Se resumen en la siguiente tabla: TIPO UART I2C SPI

D0 Rx

D1 Tx

D4 SDA

PATILLA D5 D10

D11

D12

D13

MOSI

MISO

SCK

SCL SS

2-2 La comunicación tipo UART Las patillas D0 y D1 se emplean como señales de recepción (Rx) y transmisión (Tx) respectivamente. Se pueden conectar directamente con otra tarjeta Arduino o con cualquier otro tipo de dispositivo que admita este mismo tipo de comunicación serie, y cuyas señales se adapten a las especificaciones eléctricas “TTL”.

6-2


Quizá recuerdes que estas dos patillas (D0 y D1) las hemos empleado en algún ejemplo anterior, como líneas de E/S para el control de periféricos, al igual que el resto de patillas. Sin embargo, si ahora vamos a utilizarlas como líneas de comunicación, no debemos usarlas con ningún otro fin. Dentro del sistema Arduino NANO, estas líneas (D0=Rx y D1=Tx), también están conectadas con unos circuitos electrónicos que las adaptan a las especificaciones USB. En realidad las hemos estado usando, sin saberlo, cada vez que el Arduino se comunica con el PC cuando grabamos un programa. En resumidas cuentas, las patillas D0 (Rx) y D1 (Tx), o su equivalente a través del conector USB, las podemos usar a partir de ahora para realizar nuestros propios programas de comunicación tipo UART.

3.- ESTABLECIENDO LA COMUNICACIÓN Cualquier programa que vayamos a realizar a partir de ahora, y que emplee comunicaciones serie tipo UART, necesita ser configurado y activado convenientemente. Para ello, el lenguaje Arduino dispone de dos sentencias muy sencillas y fáciles de utilizar. 3-1 Función: Serial.begin() Activa la comunicación serie tipo UART y establece, en baudios, la velocidad de la misma. Una vez ejecutada esta función, las líneas D0 y D1 se configuran como líneas de recepción (Rx) y transmisión (Tx) respectivamente. A partir de este momento no deben ser usadas como líneas de entrada / salida digital. Sintaxis: Serial.begin(baudios); baudios:

Establece la velocidad deseada en la comunicación. Los valores posibles son: 300, 1200, 2400, 4800, 9600, 14400, 28800, 38400, 57600 o 115200.

Ejemplo: void setup() { Serial.begin(9600); }

//Activa la comunicación serie a una velocidad de 9600 baudios

3-2 Función: Serial.end() Desactiva la comunicación serie. Ejecutada esta sentencia, las patillas D0 (Rx) y D1 (Tx) pueden volver a usarse como patillas de entrada / salida digital. Sintaxis: Serial.end(); Ejemplo: Serial.end();

//Desactiva la comunicación serie

4.- TRANSMISION DE DATOS Una vez establecida la comunicación podemos comenzar a realizar programas en los que, como se muestra en la figura 6-2, Arduino transmite información al mundo exterior: un PC, otro Arduino, una impresora, etc… Basta conocer las sentencias o funciones oportunas.

6-3


Figura 6-2. Transmisión de un mensaje 4-1 Función: Serial.print() Transmite datos vía serie y puede tener varias formas. Los valores numéricos se transmiten mediante sus equivalentes caracteres ASCII, uno por cada dígito. En el caso de los números en coma flotante (“float”), se transmiten con dos decimales por defecto. Los datos de tipo byte se transmiten como un único carácter ASCII. Los caracteres o cadenas de caracteres (“strings”) se transmiten tal cual. Van cerrados entre comillas simples o dobles respectivamente. Sintaxis 1: Serial.print(valor); valor:

Es el valor (de cualquier tipo) a transmitir

Ejemplos: int A = 78; Serial.print(A*2);

//Transmite “156”

float PI = 3.141592; Serial.print(PI);

//Transmite “3.14”

Serial.print(‘A’); Serial.print(“Hola”);

//Transmite “A” //Transmite “Hola”

Sintaxis 2: Serial.print(valor,formato); valor: formato:

Es el valor (de cualquier tipo) a transmitir En el caso de los números enteros permite establecer la base de numeración deseada. En el caso de los números float, establece el número de decimales a transmitir.

Ejemplos: int A = 78; Serial.print(A,BYTE); Serial.print(A,DEC); Serial.print(A,HEX); Serial.print(A,BIN); Serial.print(A,OCT);

//Transmite “N” (en ASCII 78=N) //Transmite “78” (en decimal, base 10). Por defecto //Transmite “4E” (en hexadecimal, base 16) //Transmite “01001110” (en binario, base 2) //Transmite “116” (en octal, base 8)

float PI = 3.141592; Serial.print(PI,0); Serial.print(PI,2); Serial.print(PI,5);

//Transmite “3” (sin decimales) //Transmite “3.14” (con 5 decimales, por defecto) //Transmite “3.14159” (con 5 decimales)

6-4


4-2 Función: Serial.println() Tiene las mismas formas que la función anterior. La única diferencia es que tras transmitir los datos, automáticamente transmite un código de “retorno de carro” (\r o 0x0D) y un “avance de línea” (\n o 0x0A). Sintaxis: Serial.println(valor); Serial.println(valor,formato); valor: formato:

Es el valor (de cualquier tipo) a transmitir En el caso de los números enteros permite establecer la base de numeración deseada. En el caso de los números float, establece el número de decimales a transmitir.

4-3 Ejemplos de transmisión Ya basta de teoría. Hemos visto las sentencias fundamentales para establecer una comunicación serie y transmitir datos. Es hora de hacer algunos sencillos programas que nos permitan introducirnos al fascinante mundo de la transmisión de datos en serie. +5Vcc

D1 VIN D0 GND RESET RESET GND +5V D2 A7 D3 A6 D4 A5 D5 A4 D6 A3 D7 A2 D8 A1 D9 A0 D10 AREF D11 3V3 D12 D13 ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Es el más sencillo y clásico de los ejemplos posibles. Consiste en transmitir un mensaje cada vez que se acciona un pulsador E10 conectado en la patilla D4, según el esquema de la figura 6-3. Aunque aparece en el esquema, lo concerniente al interface USB no va con nosotros. Simplemente representa que las líneas D0 y D1 enlazan con el PC a través del interface USB. Ya hemos comentado que estas líneas no debemos usarlas con otros fines en aquellos programas que realicen comunicaciones serie.

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

4-3-1 Ejemplo: Saludos

Tx

Interface USB Rx con el PC

Figura 6-3. Circuito del ejemplo Saludos

E10

En la función void setup() tenemos como novedad a la función Serial.begin(9600). Habilita al Arduino para realizar comunicaciones serie tipo UART a una velocidad de 9600 baudios. Recuerda que una vez ejecutada esta función, no debes hacer uso de las patillas D0 y D1, ya que se emplean ahora para la recepción (Rx) y transmisión (Tx) de datos. void setup() { pinMode(4,INPUT); Serial.begin(9600); }

//D4 es entrada //Ajusta velocidad de la comunicación a 9600 baudios

Como novedad del programa principal, en la función void loop(), comentar la presencia de la función Serial.println() que transmite vía serie la cadena indicada (“Saludos desde Arduino …”) y que añade automáticamente los caracteres de control /r y /n (retorno de carro y avance de línea). Serial.println("Saludos desde Arduino ..."); //Transmite el saludo La transmisión se produce cuando se detecta un pulso en la patilla D4 de entrada. ¿Cómo verificar el funcionamiento del programa? Si tenemos en cuenta que el programa del Arduino trata de transmitir un mensaje al PC, hemos de suponer que dicho PC también deberá tener un programa para recibir ese mensaje y, por lo menos, visualizarlo. A este tipo de programas se les llama “programas de comunicaciones”. Para ordenadores PC bajo plataformas Windows podemos encontrar un buen número de

6-5


ellos: HyperTerminal (incluido en Windows), Docklight, Procomm, Smartcomm, etc… Incluso, el propio entorno de trabajo de Arduino, incluye un sencillo programa de comunicaciones llamado “Serial monitor”, que nos facilita la comprobación de programas y ejemplos de éste tipo. Para activarlo basta con pulsar el icono representado mediante una lupa. Ver la figura 6-4.

Figura 6-4. El monitor serie incorporado en el entorno de Arduino Cada vez que se acciona el pulsador E10 conectado con la patilla D4, Arduino transmite el mensaje que será visualizado en la ventana de ese monitor. Si estás familiarizado con los programas de comunicaciones para PC, puedes utilizar el que más te guste. El resultado deberá ser el mismo. Por ejemplo, puedes probar con el programa Hyper Terminal que incorpora el propio Windows. Una vez configurado convenientemente (velocidad, canal COM a emplear, Nº de bits, etc…), deberás apreciar algo parecido a lo mostrado en la figura 6-5. Figura 6-5. Recepción del mensaje desde el programa Hyper Terminal

4-3-2 Ejemplo: Números Con este ejemplo tienes una buena ocasión de repasar los diferentes sistemas de numeración. Se emplea el mismo esquema eléctrico que el mostrado en la figura 6-3. Cada vez que se pulsa E10, conectado con la patilla D4, se transmiten 10 números correlativos. Cada número se transmite en diferentes formatos: decimal o base 10 (DEC), hexadecimal o base 16 (HEX), octal o base 8 (OCT) y binario o base 2 (BIN). El resultado de la ejecución del programa se puede observar en la ventana del monitor serie de Arduino muestra en la figura 6-6.

Figura 6-6. El ejemplo Números

6-6


4-3-3 Ejemplo: Monitor_Remoto +5Vcc


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Aquí tienes un buen ejemplo práctico. Se trata de monitorizar el estado lógico de cuatro interruptores, E3:E0, conectados con las patillas D4:D7. Monta el circuito de la figura 6-7. El programa es muy sencillo. Se van leyendo cada una de las entradas D4:D7. Si están a nivel “1” se transmite el carácter ‘1’. Si están a nivel “0” se transmite el carácter ‘0’.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

ARDUINO NANO

Tx


E0 E1 E2 E3

Como el programa se repite de forma indefinida, cada vez que una de los interruptores del entrenador Universal Trainer cambie de estado, inmediatamente se verá reflejado en el monitor serie.

Figura 6-7. Monitorización remota El montaje práctico se muestra en la fotografía de la figura 6-8 y el resultado de la monitorización en la figura 6-9. Es un ejemplo que abre las puertas a múltiples aplicaciones.


Figura 6-9. Monitorización

5.- RECEPCION DE DATOS De la misma manera, una vez establecida y activada la comunicación, Arduino NANO puede empezar a recibir los bytes que le transmite un PC, otro Arduino o cualquier otro dispositivo. Esto no afecta al programa que en ese momento se esté ejecutando. Simplemente, cada vez que se recibe un byte, se guarda automáticamente en una memoria RAM interna que recibe el nombre de “buffer”. Se representa en la figura 6-10. El buffer es capaz de almacenar un máximo de 64 bytes según se van recibiendo. Si se reciben más bytes sin haber leído o “sacado” los que hubiera en ese momento, el buffer se desborda y se van perdiendo los bytes que primero llegaron. Figura 6-10. El buffer de recepción Mediante las funciones oportunas del lenguaje de programación Arduino, tenemos la posibilidad de conocer si se ha recibido o no algún byte, es decir, si hay alguno almacenado en el buffer. También podemos leerlos en el mismo orden en que fueron llegando.

6-7


Observa la figura 6-11. Muestra un portátil conectado con una tarjeta Arduino cualquiera (la UNO en la figura), mediante el puerto USB. Desde él se transmiten los caracteres de la cadena “HOLA”, que son recibidos por Arduino y almacenados en su buffer interno de memoria RAM.

Figura 6-11. Ejemplo de recepción 5-1 Función: Serial.available() Devuelve el número de bytes que se han recibido y están por tanto almacenados en el buffer de memoria. Si devuelve el valor 0 es que no se ha recibido ningún byte y el buffer está vacío. El valor máximo que puede devolver es de 64. Sintaxis: Serial.available(); Ejemplo: byte A; A=Serial.available(); …. while(¡Serial.available());

//A se carga con el valor 4 suponiendo el ejemplo de la figura 6-11 //Espera mientras no se reciba ningún byte

5-2 Función: Serial.read() Lee del buffer los bytes según se han recibido. Si no se ha recibido nada, devuelve el valor de -1. Sintaxis: Serial.read(); Ejemplo: char A; A=Serial.read(); A=Serial.read(); A=Serial.read(); A=Serial.read();

//Variable tipo char //Lee del buffer el primer carácter recibido (H) //Lee del buffer el siguiente carácter (O) //Lee del buffer el siguiente carácter (L) //Lee del buffer el siguiente carácter (A)

5-3 Función: Serial.parseint() Lee del buffer un número entero con signo recibido por el canal serie. El número recibido únicamente puede estar compuesto de los caracteres 0 al 9, y del signo (+ o -). No se admite ningún otro carácter. Estará comprendido entre -32768 y +32768.

6-8


Sintaxis: Serial.parseint(); Ejemplo: int N; N=Serial.parseint();

//Variable tipo int //N se carga con el número entero (2 bytes) recibido vía serie

5-4 Función: Serial.parsefloat() Lee del buffer el número en coma flotante (número real) recibido vía serie. El número recibido únicamente puede estar compuesto de los caracteres 0 al 9, del punto decimal (.) y del signo (-). No se admite ningún otro carácter. Sintaxis: Serial.parsefloat(); Ejemplo: float N; N=Serial.parsefloat();

//Variable de tipo float //N se carga con el número flotante (4 bytes) recibido vía serie

5-5 Ejemplos de recepción Con las funciones o sentencias que acabamos de ver, ya estamos listos para presentar y trabajar con una serie de ejemplos que reciben datos desde un PC, otro Arduino o cualquier otro tipo de dispositivo o periférico cualquiera. Los datos recibidos serán procesados y tratados por nuestro controlador Arduino NANO de acuerdo a las necesidades. En resumidas cuentas, tenemos lo necesario para que nuestro Arduino pueda transmitir y/o recibir datos, e interaccionar con el mundo exterior mediante las comunicaciones serie tipo UART. +5Vcc

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

5-5-1 Ejemplo: Control_Remoto

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Dichos leds se conectan con las patillas D4:D7 respectivamente. A través del interface USB, Arduino recibe desde el PC cuatro posibles caracteres correspondientes a otros tantos comandos: ‘0’, ‘1’, ‘2’ y ‘3’.


Con este ejemplo de indudable interés práctico, vas a poder controlar de forma remota la activación o desactivación de los leds S3:S0 del laboratorio Universal Trainer, desde un PC. Realiza el montaje del esquema de la figura 6-12.

Tx

Interf ace USB Rx con el PC

S0 S1 S2

Figura 6-12. Control remoto

S3

En función del comando recibido, uno de los leds de salida cambia de estado: comando ‘0’  S0, ‘1’  S1, ‘2’  S2 y ‘3’  S3. Observa y estudia el siguiente fragmento del programa: case '0': digitalWrite(4,!digitalRead(4)); break;

//Si el comando es '0'... //El led S0 cambia de estado

6-9


Si se recibe el comando ‘0’, se lee el estado de la patilla D4 (led S0) y se invierte (¡digitalRead(4)). El resultado se escribe sobre la misma patilla D4 (digitalWrite()). Es decir, si la patilla D4 está a nivel “0”, pasa a nivel “1” y viceversa. Se emplea la misma técnica de “cambio de estado” para el resto de comandos y patillas. 5-5-2 Ejemplo: Calculadora El ejemplo emula el funcionamiento de una calculadora capaz de realizar las cuatro operaciones básicas (suma, resta, multiplicación y división) entre dos números enteros. Ambos números se transmiten desde el PC al Arduino vía comunicación serie. Así mismo, el resultado obtenido por Arduino, se transmite ahora al PC vía serie. Tenemos por tanto una comunicación en ambos sentidos: Arduino ↔ PC . La novedad principal del programa reside en que vamos a crear y usar nuestra primera función. Una función es a su vez un conjunto de funciones o sentencias que se deben ejecutar varias veces. En lugar de escribirlas tantas veces como se necesiten, se escriben una única vez y se usan las veces que sea necesario. En este caso hemos creado la función Dato(). Está formada a su vez por otras tres funciones: While(), Serial.parseInt() y return(). Cada vez que nuestro programa llame a la función Dato(), se ejecutarán todas las funciones que ésta contiene devolviendo el número entero que se reciba vía serie. int Dato() //Esta función espera a recibir un nº int por el canal serie { while(!Serial.available()); //Esperar si no se recibe nada int N=Serial.parseInt(); //Lee el nº int return(N); //Devuelve el nº int }          

Se aconseja que las funciones creadas por el usuario se definan y escriban al principio del programa, antes incluso que la función void loop(). No se puede usar una función que no haya sido previamente declarada. El nombre de la función debe empezar siempre por una letra. Todas las sentencia que contiene una función deben estar encerradas entre llaves ({ }). Si la función, como en este caso, devuelve un valor de tipo int, se debe declarar como tal (int Dato()). La sentencia return() finaliza la función y puede devolver el valor que le indiquemos (return(N) en el ejemplo). Una función puede tener también parámetros de entrada con los que operar. Se “pasan” desde el programa principal. Una función puede “llamar” a otra función. Al finalizar una función se retorna al programa principal o a la función que la llamó. El programa principal hace uso o “llama”· a una función, ejecutando las instrucciones que contenga, tantas veces como haga falta:

A=Dato(); Serial.print(A); …. …. B=Dato(); Serial.print(B);

//Espera al primer operando

//Espera al segundo operando //Imprime el segundo operando

Nuestro ejemplo espera a que introduzcamos vía serie, desde el PC, el primer operando (A=Dato()). Luego debemos introducir el símbolo de la operación a realizar (+, -, *, /). Por último introducimos el segundo operando (B=Dato()). Calcula el resultado según la operación deseada, y lo transmite vía serie al PC: Serial.print(" = "); Serial.println(R);

//Retransmite el resultado

6 - 10


En la figura 6-13 se muestra unas cuantas operaciones aritméticas de ejemplo. Recordemos que las operaciones se realizan entre dos datos de 16 bits que pueden expresar valores de +/- 32767. Hemos empleado el propio monitor serie que incluye el entorno Arduino. En el recuadro superior introducimos el valor del operando A, el símbolo de la operación a realizar (+, -, *, /) y el valor del operando B. Se introducen seguidos del RETURN. En este ejemplo se aconseja elegir la opción remarcada: “No hay fin de línea”. De esta manera, cuando introducimos un operando o símbolo seguido de RETURN, el monitor serie lo transmite al Arduino pero SIN incluir el código propio del RETURN (0x0D en HEX). Figura 6-13. Calculadora +5Vcc

5-5-3 Ejemplo: Potencia_PWM

D1 VIN D0 GND RESET RESET GND +5V D2 A7 D3 A6 D4 A5 D5 A4 D6 A3 D7 A2 D8 A1 D9 A0 D10 AREF D11 3V3 D12 D13 ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

El led S0 del laboratorio Universal Trainer se conecta con la patilla D4. Su brillo se regulará de forma remota mediante el terminal serie del entorno Arduino.

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Se trata de otro ejemplo de control remoto. En esta ocasión vamos a hacer un programa amigable que, de forma interactiva, nos pregunte por el porcentaje de potencia que deseamos aplicar a un led de salida. Nos devuelve la duración del ciclo útil y genera la señal PWM correspondiente. Monta el circuito de la figura 6-14.

Tx


S0

Figura 6-14. Control remoto de la señal PWM

La figura 6-15 nos muestra el terminal serie con los valores de algunas de las pruebas realizadas. Cuando transmitimos desde el PC la potencia deseada (en %), el Arduino calcula y retransmite al PC el valor de la duración del pulso. Se aconseja elegir la opción remarcada: “No hay fin de línea”. De esta manera, cuando introducimos el valor de la potencia seguido de RETURN, el monitor serie lo transmite al Arduino pero SIN incluir el código propio del RETURN (0x0D en HEX).

Figura 6-15. Generando señales PWM

Trabajo personal Proponemos que diseñes un programa amigable e interactivo que permita controlar la potencia que se aplica a los leds S3:S0 conectados respectivamente con las patillas D4:D7 del controlador Arduino NANO.

6 - 11


5-5-4 Ejemplo: Servo_Control_Remoto En la misma línea que el ejemplo anterior, se trata de controlar de forma remota el posicionamiento de un servo. De forma interactiva, mediante el terminal serie del entorno Arduino, se pregunta el número de grados que el servo debe girar (entre 0º y 180º).

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Servo 900-00008

+5Vcc

La figura 6-16 muestra el esquema de las conexiones a realizar.


Figura 6-16. Control remoto de un servo

Vdd GND 2 3

1

Tx

PWM

ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Como ya sabemos, las patillas D0 y D1 se emplean como líneas de recepción (Rx) y transmisión (Tx) respectivamente. Van a parar al interface USB que conecta Arduino NANO con el PC. Desde éste, transmitimos en grados el desplazamiento que deseamos que gire el servo.


El servo se controla mediante una señal PWM desde la patilla D3, al igual que en los ejemplos del tema anterior.

+5Vcc

Trabajo personal Imagina una máquina herramienta cuyo usillo debe realizar diferentes desplazamientos. Proponemos diseñar un programa mediante el cual el servo realice una secuencia de cinco maniobras consecutivas. En la pantalla del PC recibiremos los mensajes oportunos para que, de forma sencilla, cualquier usuario pueda definir las diferentes maniobras. Por ejemplo: VALORES GIRO TEMPORIZACION REPETICION

1 10º 5”

2 90º 3”

MANIOBRA 3 5 45º 135º 5” 2”

5 180º 6”

6

10

Esto se puede pude traducir como que en la maniobra nº 1, el servo gira 10º y espera 5”, en la maniobra nº 2 gira 90º y espera 3”, etc… La repetición representa el número de veces que se han de repetir las maniobras anteriores. Una vez que finaliza toda la secuencia, el sistema queda disponible para iniciar una nueva.

6.- MAS EJEMPLOS Ahora que ya sabemos comunicar nuestro Arduino NANO con el PC (o con cualquier otro equipo), y transferir datos en ambos sentidos mediante la comunicación serie tipo UART, quizá sea un buen momento para estudiar nuevas funciones y posibilidades del lenguaje Arduino. 6-1 Funciones matemáticas Anteriormente vimos el ejemplo “Calculadora”, en el que simulábamos su funcionamiento haciendo las operaciones básicas (+, -, *, /) entre dos números enteros. Avanzamos un paso más para trabajar ahora con números “float” y de paso ver algunas de las funciones matemáticas más importantes incluidas en el lenguaje de programación Arduino. No vamos a necesitar tener conectado ningún periférico en el controlador. Nos basta con mantener la conexión USB con el PC.

6 - 12


Aunque los programas que proponemos son sencillos e interactivos con el usuario, siempre son susceptibles de ser mejorados. Te animamos a ello. 6-1-1 Ejemplo: Min_Max Utiliza las funciones min() y max() que permiten obtener el valor mínimo y máximo de dos números respectivamente. La figura 6-17 muestra la pantalla del terminal serie del entorno Arduino, con el resultado de algunos ejemplos. Figura 6-17. Calculando mínimos y máximos Sintaxis: min(A,B); max(A,B); A: B:

Es el primer número. Puede ser cualquier expresión de cualquier tipo. Es el segundo número. Puede ser cualquier expresión de cualquier tipo.

6-1-2 Ejemplo: Absoluto La función abs() permite obtener el valor absoluto de un número. El valor absoluto de un número es siempre un número positivo. La figura 6-18 muestra algunos ejemplos. Figura 6-18. El valor absoluto Sintaxis: abs(A); A:

Es el número cuyo valor absoluto se calcula.

6-1-3 Ejemplo: Potencia Mediante la función pow() se calcula la base de un número elevado al exponente o potencia indicada. La figura 6-19 muestra los resultados de algunos ejemplos. Figura 6-19. Cálculo de la potencia de un número Sintaxis: pow(base,exponente); base: exponente:

El número (float) La potencia a la que se eleva la base (float)

6-1-4 Ejemplo:Raiz Emplea la función sqrt() para calcular la raíz cuadrada de un número. La figura 6-20 muestra algunos de los resultados obtenidos. Observa cómo trabajamos con cinco decimales (o los que sean). Figura 6-20. Raíz cuadrada Sintaxis: sqrt(A); A:

Es un número de cualquier tipo.

6 - 13


6-1-5 Ejemplo: Trigonometría Las funciones trigonométricas sin(), cos() y tan() permiten obtener el seno, coseno y tangente respectivamente de un ángulo expresado en radianes. El ejemplo pide el valor de un ángulo expresado en grados y calcula también su equivalente en radianes. La figura 6-21 muestra la solución a varios ejemplos. Figura 6-21. Funciones trigonométricas Sintaxis: sin(A); cos(A); tan(A); A:

Es el valor del ángulo expresado en radianes

6-2 Funciones avanzadas El lenguaje Arduino dispone, además de las ya conocidas, otras funciones para el control del tiempo y también para realizar ciertas operaciones especiales con las entradas y salidas digitales. Ahora que sabemos comunicarnos vía serie con el exterior, es un buen momento para estudiarlas, usarlas y transmitir sus resultados al PC a través del terminal serie del entorno Arduino. 6-2-1 Ejemplo: Tiempo_On Gracias a la función millis() es posible conocer el tiempo que lleva Arduino ejecutando un programa desde que se conectó la alimentación o se reinició mediante el RESET. Esta función devuelve un número largo sin signo, “unsigned long” (4 bytes), que representa el tiempo en milisegundos. Este número puede ir 32 desde 0 mS hasta 4.294.967.295 mS (2 -1), que representa aproximadamente a unos 50 días de funcionamiento. En el ejemplo (figura 6-22) se visualiza en segundos el tiempo trascurrido desde el reinicio, y se intercala una temporización de 5000 mS entre una visualización y la siguiente. Figura 6-22. Tiempo transcurrido en segundos Sintaxis: millis(); 6-2-2 Ejemplo: Tiempo_On_V2 De forma similar, la función micros() también nos permite conocer el tiempo que lleva Arduino ejecutando un programa desde que se conectó la alimentación o se reinició mediante el RESET. En esta ocasión la función devuelve un número largo sin signo, “unsigned long” (4 bytes), que representa el tiempo en microsegundos. Este número puede ir desde 0 µS hasta 4.294.967.295 µS 32 (2 -1), que representa aproximadamente a unos 70 minutos de funcionamiento. En el ejemplo (figura 6-23) se visualiza en microsegundos el tiempo trascurrido desde el reinicio, y se intercala una temporización de 5000 mS entre una visualización y la siguiente. Figura 6-23. Tiempo transcurrido en microsegundos Sintaxis: micros();

6 - 14


6-2-3 Ejemplo: Medir_Pulso En el tema anterior se estudiaron las señales PWM que se generaban mediante la función analogWrite(). La duración del ciclo útil se establecía mediante un valor comprendido entre 0 y 255. En este ejemplo vamos a ver la relación que hay entre ese valor y el tiempo real en µS que dura un ciclo útil o nivel “1”. Para ello vamos a emplear una nueva función: pulseIn(). Esta función es capaz de medir el tiempo que dura un pulso a “1” o un pulso a “0” de una señal aplicada por cualquier patilla de entrada digital. 32 Devuelve un valor entero grande sin signo (“unsigned long”) comprendido entre 0 µS y 4.294.967.295 µS (2 1), equivalente a unos 70 minutos de duración. Sintaxis: pulseIn(pin, nivel, tiempo); pin: Representa la patilla de entrada con la señal a medir. nivel: Indica si se va a medir la duración del pulso a “1” (1) o del pulso a “0” (0). tiempo: Se trata de un valor “unsigned long” que indica, en micro segundos, el tiempo que se ha de esperar para hacer la medida. Es opcional y por defecto es de 1000000 µS (1 seg.). Si transcurrido ese tiempo (“Time-Out”), no se produce el pulso a “1” o a “0” que queremos medir, se devuelve el valor 0. Vas a montar el circuito del esquema de la figura 6-24. Por la patilla de salida D11 se genera una señal PWM cuya anchura o ciclo útil indicaremos tecleando un valor de entre 0 y 255. Utilizamos para ello el terminal serie del entorno Arduino El brillo del led S0 varía en función de ese valor.

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 D1 VIN D0 GND RESET RESET GND +5V D2 A7 D3 A6 D4 A5 D5 A4 D6 A3 D7 A2 D8 A1 D9 A0 D10 AREF D11 3V3 D12 D13 ARDUINO NANO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

La patilla D11 se conecta a su vez con la patilla de entrada D2. Mediante pulseIn() medimos el tiempo que la señal en esta patilla se mantiene a “1”. Ese tiempo representa exactamente los microsegundos que dura el ciclo útil de la señal PWM generada.

+5Vcc

Tx


S0

Figura 6-24. Midiendo el ciclo útil En la figura 6-25 se muestra el resultado obtenido para diferentes valores del ciclo útil. Recordemos que el sistema Arduino genera una señal PWM de aproximadamente 490 Hz de frecuencia F con un periodo T de 2040 µS. Todos los valores indicados son aproximados y pueden variar ligeramente en función de múltiples factores. Se aprecia que con la anchura mínima del ciclo útil (0) la duración es, evidentemente, de 0 µS. Con una anchura de 254, la duración es de 2010 µS. La máxima posible sería 255, el 100%, pero esto nos daría una duración de 0 µS, ya que en este caso la señal PWM es fija a nivel “1”. No es un pulso. Desborda el tiempo (Time-Out) de la función pulseIn() y devuelve el valor 0. Figura 6-25. Duración de diferentes ciclos útiles La figura 6-26 muestra la señal PWM capturada mediante un osciloscopio. Se aprecia claramente la lectura que ofrecen los cursores que miden la anchura del nivel “1” de una señal PWM, cuyo ciclo útil es de 100. El resultado de la medida es de 800 µS, muy cercano a los 788 µS ofrecido en la figura 6-25 para una misma señal.

6 - 15


Figura 6-26. Señal PWM con 800 µS de ciclo útil 6-2-4 Ejemplo: Frecuencímetro Como se muestra en la figura 6-27, toda señal digital está compuesta de transiciones de niveles lógicos “1” y “0”. Con pulseIn() podemos medir el tiempo que dura el semiperiodo en el que la señal está a nivel “1” (SMP1), y el semiperiodo en el que está a nivel “0” (SMP0). La suma de ambos semiperiodos da lugar al periodo T, que es la parte que se repite en una señal. Conocido el periodo podemos calcular también la frecuencia F de esa señal. Figura 6-27. Señal digital Tx


DIG

1-50Hz

F =

1H z

Up Sel .

1

Dn Adj.

E10 MEDIR

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

ARDUINO NANO

Monta el esquema de la figura 6-28. Por primera vez vamos a utilizar el generador lógico del entrenador Universal Trainer. Nos va a proporcionar la señal de onda cuadrada cuya frecuencia el Arduino será capaz de medir mediante pulseIn(). Si dispones de la versión V1 o V2 del entrenador, debes usar el generador lógico y NO el generador de funciones. Selecciona la frecuencia más baja de las disponibles. Figura 6-28. Esquema del frecuencímetro

Si estás usando la última versión del Universal Trainer, la V3, debes seleccionar la señal de salida de tipo digital (DIG), la escala más baja (1-50 Hz) y ajustar, mediante el potenciómetro, la frecuencia de salida más baja posible. El programa espera una pulsación en la patilla D3 en la que le hemos conectado el pulsador E10 del entrenador. Seguidamente lee la duración del semiperiodo positivo (SMP1) y del negativo (SMP0) de la señal que proporciona el generador lógico y que se aplica por la patilla D2. A continuación calcula el periodo T y la frecuencia F. Por último visualiza los resultados transmitiéndolos vía serie al terminal del entorno Arduino.

Figura 6-29. Midiendo una frecuencia

6 - 16


La figura 6-29 muestra el resultado de la ejecución del programa. El generador de funciones se ha ajustado a una señal digital cuya frecuencia es de 28 Hz (o cualquier otra). La ventana del terminal serie nos ofrece las medidas realizadas: SMP1=17802 µS, SMP0=17778 µS, el periodo T es de 0.035580 mS y la frecuencia F de 28.1 Hz. Puedes probar con cualquier frecuencia que el generador lógico de tu entrenador sea capaz de suministrar. Quizá observes que cuanto mayor sea esta, menor precisión se obtiene en la medida. Esto es debido a que el pulso mínimo que la función pulseIn() puede medir es de aproximadamente unos 10 µS, lo que hace un periodo mínimo de 20 µS que equivale a una frecuencia máxima de unos 50 KHz. 3-2-5 Ejemplo: Tiempo_de_Activación Tx

Interface USB Rx con el PC E10

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

Otro ejemplo con múltiples aplicaciones prácticas. Empleando la función pulseIn(), se trata de medir el tiempo en que un pulsador (o cualquier dispositivo similar) se mantiene activado. Monta el circuito de la figura 6-30. En este caso empleamos el pulsador E10 del entrenador que conectamos con la patilla D2. En reposo está a nivel “1”. Cada vez que se pulsa produce un nivel “0”. Figura 6-30. Medir el tiempo de activación del pulsador

ARDUINO NANO

La función pulseIn() tiene un parámetro que expresa el tiempo que debe esperar a que se produzca el pulso que queremos medir. Se trata de un entero largo sin signo (“unsigned long”) que está comprendido 32 entre 0 µS y 4.294.967.295 µS (2 -1). Equivale a una espera máxima de unos 70 minutos de duración. Si transcurre dicho tiempo sin que llegue el pulso (Time-Out), la función devuelve el valor 0. En este ejemplo el valor de espera se establece en la variable “TO” que se carga con el valor 10000000 (10 segundos). En la figura 6-31 se muestra algunos resultados: 1. E10 se ha pulsado durante 0.14 segundos. 2. E10 no se ha pulsado en el tiempo establecido de 10 segundos. Ha habido Time-Out. 3. E10 se ha mantenido pulsado durante 3.39 segundos.

Figura 6-31. Pulsaciones de diferentes pulsaciones

Trabajo personal Prueba a cambiar el pulsador E10 por el interruptor E0. Cuando lo mueves de nivel “1” a nivel “0” y de nuevo a “1”, ¿qué observas en las diferentes medidas?. El error se debe al efecto “rebote” del que ya hemos hablado. Los interruptores del entrenador Universal Trainer, al igual que dispositivos similares, presentan dicho efecto. ¿Por qué no ocurría con el pulsador? Los pulsadores E10 y E11 del entrenador están dotados de un circuito anti rebote como el que se muestra en la figura 6-32. Por la línea E10 se obtiene un pulso “limpio” con transición 1-0-1 cada que se pulsa.

6 - 17

ARDUINO: La tecnología al alcance de todos TEMA 6: Las comunicaciones www.microcontroladores.com +5Vcc

El circuito de los interruptores que hay en el entrenador es muy parecido. Le falta el condensador. Si pruebas a conectar un condensador de 100 n entre la línea E0 y GND observarás que las medidas mejoran ahora notablemente.

4K7 E10 E10 470

Figura 6-32. Circuito anti rebote

100n

7.- MAS FUNCIONES PARA LAS COMUNICACIONES Hemos visto las funciones más importantes empleadas en las comunicaciones serie, y también hemos practicado con ellas. Sin embargo, el lenguaje Arduino tiene más funciones relacionadas con la comunicación serie tipo UART. En este apartado vamos a hacer un resumen de ellas, dejando que seas tú mismo quien experimentes con las mismas y las utilices según te convenga.

7-1 Función: Serial.find() Lee los datos que hay en el buffer de recepción serie en busca de la cadena de caracteres indicada. La función devuelve “true” (verdad) si la cadena se encuentra efectivamente en el buffer. Si devuelve “falso” es porque la cadena no se ha encontrado y no hay más datos en el buffer. Sintaxis: Serial.find(cadena); cadena:

Es la cadena que se desea encontrar dentro del buffer.

7-2 Función: Serial.findUntil() Es similar a find(), pero la búsqueda se detiene si no se encuentra el final indicado. Es útil para encontrar una cadena con un final determinado, por ejemplo, retorno de carro (\r). Sintaxis: Serial.findUntil(cadena,final); cadena: final:

Es la cadena a buscar dentro del buffer Es el carácter con que debe finalizar la cadena

7-3 Función: Serial.peek() Devuelve el siguiente byte o carácter que haya en el buffer de recepción, pero sin sacarlo del mismo como hacía la función Serial.read(). Sintaxis: Serial.peek();

6 - 18


7-4 Función: Serial.readBytes() Lee caracteres del puerto serie y los almacena en el buffer indicado. La función finaliza si se ha leído el número de caracteres indicado, o se excede el tiempo de espera establecido (Time-Out). Devuelve el número de caracteres almacenados en el buffer. Un valor 0 indica que no se recibió ninguno. Sintaxis: Serial.readBytes(buffer,número); buffer: número:

Buffer donde se reciben y guardan los caracteres (p.e. char recibir[ ]) Número de bytes a recibir (int)

7-5 Función: Serial.readBytesUntil() Lee caracteres del puerto serie y los va almacenando en el buffer indicado. La función finaliza cuando se detecte un determinado carácter, o se hayan recibido el número de caracteres indicado, o bien se excede el tiempo de espera establecido (Time-Out). Devuelve el número de caracteres recibidos y almacenados en el buffer. Un valor 0 indica que no se recibió ninguno. Sintaxis: Serial.readBytesUntil(carácter,buffer,número); carácter: buffer: número:

Es el carácter que, cuando se recibe, finaliza la recepción. Buffer donde se guardan los caracteres recibidos (p.e. char recibir[ ]) Número de bytes a recibir (int)

7-6 Función: Serial.setTimeout() Permite ajustar el tiempo de espera que emplean ciertas funciones como Serial.parseInt(), Serial.readBytes() o Serial.readBytesUntil(), para que se den por finalizadas. Sintaxis: Serial.setTimeout(tiempo); tiempo:

Es un número entero largo (long) que expresa, en milisegundos, el tiempo de espera. Por defecto es de 1000 mS (1 segundo).

7-7 Función: Serial.write() Escribe uno o más bytes sobre el puerto serie. Para enviar bytes que representan dígitos o caracteres se aconseja el empleo de Serial.print(). Sintaxis: Serial.write(byte); Serial.write(cadena); Serial.write(buffer,número); byte: cadena: buffer: número:

Es el byte a transmitir Representa la cadena o serie de bytes a transmitir El buffer que contiene los bytes a transmitir El número de bytes contenidos en el buffer a transmitir

6 - 19


7-8 Función serialEvent() Es una función a la que se le llama cada vez que se recibe un byte, ejecutándose así todas las sentencias que contenga. Se debe emplear la función Serial.read() para leer el dato recibido. Sintaxis: void serialEvent() { …. …. }

6 - 20

ARDUINO: La tecnología al alcance de todos TEMA 7: Las señales analógicas www.microcontroladores.com

TEMA 7: Las señales analógicas 1.- INTRODUCCIÓN Es probable que en algún momento hayamos hablado de señales o entradas “analógicas”, pero ¿qué son?, ¿para qué sirven?, ¿dónde están?, ¿cómo se manejan? Vamos a dedicar este tema a explicarlas tanto de forma teórica como práctica a base de diferentes ejemplos. Hasta el momento hemos visto a nuestro controlador Arduino como un sistema digital que únicamente entiende y manipula señales digitales compuestas de niveles “1” y “0”. Con estos niveles lógicos o bits podemos realizar cualquier tipo de operación aritmético / lógica, operaciones de control, temporizaciones, sonidos, regulación y hasta comunicaciones, como hemos estudiado en los temas precedentes. En el mundo “digital” todo se contempla como si únicamente hubiera dos posibles valores. Un interruptor o pulsador puede estar activado (“1”) o desactivado (“0”). Un led se puede encender o apagar. El sonido se puede generar a partir de una señal de onda cuadrada, compuesta de “1”s y “0”s, con diferentes frecuencias. La regulación en el brillo de un led, la velocidad de un motor o el posicionamiento de un servo, se puede realizar mediante señales PWM, que también son señales compuestas de “1”s y “0”s. Sin embargo el mundo “real” es diferente. En la naturaleza nos podemos encontrar con parámetros o magnitudes que pueden adquirir múltiples valores, no sólo “1”s y “0”s. Pensemos por ejemplo en la temperatura. Se trata de una magnitud física que constantemente está variando en el tiempo. No hace la misma temperatura de madrugada, que al mediodía o a la noche. Si dispusiéramos de un sensor capaz de capturar la temperatura y ofrecernos una tensión proporcional a la misma, veríamos que esa tensión puede tener multitud de valores posibles, como se muestra en la figura 7-1. La temperatura es una magnitud analógica. Gracias al sensor obtenemos una tensión de 2V a las 5h de la mañana. A las 9h la tensión es de unos 4V y sube a unos 5V a las 15h. A partir de las 16h la temperatura va disminuyendo y, por la tanto, la tensión que ofrece el sensor también. Únicamente nos hace falta establecer una relación entre tensión (V) y temperatura (ºC). Figura 7-1. La temperatura es una magnitud analógica Piensa en las múltiples magnitudes físicas analógicas que nos rodean. Mediante los sensores o “transductores” apropiados podemos convertir esas magnitudes a sus tensiones analógicas equivalentes:      

Humedad y/o humedad relativa. Nos permite conocer la cantidad de vapor de agua que hay en la atmósfera terrestre. Presión atmosférica. Con el sensor oportuno podemos conocer la presión que ejerce el aire sobre la tierra. Peso. Podemos medir la fuerza con la que un cuerpo actúa sobre un punto de apoyo. Velocidad. Con los sensores apropiados podemos medir la velocidad a la que se desplaza el aire, una persona, un vehículo, etc… Luz. Podemos medir la luz ambiente o la luz que incide sobre un objeto. Hay sensores que detectan luz visible, infra roja, ultra violeta, etc… Sonido. Con los transductores existentes se puede medir, conocer y/o detectar ruidos, sonido ambiente, volumen, etc…

2.- CONVERSION DIGITAL Hoy en día existen en el mercado todo tipo de sensores y transductores capaces de ofrecer una tensión analógica equivalente a la magnitud física que están midiendo. Sin embargo, ningún sistema digital es capaz de manipular ni procesar directamente esas tensiones analógicas. Nuestro controlador Arduino tampoco.

7-1


Primero es necesario convertir las tensiones analógicas a sus equivalentes valores digitales. Para ello se emplean unos circuitos electrónicos llamados “Convertidores Analógicos Digitales o Analog Digital Converters”, abreviadamente “ADC”. La figura 7-2 resume los elementos necesarios para poder procesar una magnitud analógica como puede ser la temperatura.

Figura 7-2. Conversión analógica 1. El sensor o transductor, en este caso de temperatura, capta la magnitud física a medir. A su salida ofrece una tensión analógica proporcional a esa temperatura. 2. Esa tensión se introduce al convertidor analógico/digital ADC. Este circuito ofrece a su salida un valor binario equivalente a esa tensión. 3. El valor binario puede ser leído por el sistema digital, que puede ser nuestro Arduino o cualquier tipo de controlador. 4. El sistema digital es ahora capaz de realizar cualquier tratamiento con ese valor binario: registrarlo en memoria, realizar operaciones aritmético / lógicas, visualizarlo, transferirlo a otro sistema, etc… Casi todos los microcontroladores actuales llevan integrado el circuito convertidor ADC. Básicamente solo hace falta conectarle el sensor o transductor correspondiente a la magnitud física que queremos medir y tratar. El controlador Arduino NANO, como no podía ser menos, es uno de ellos. La mayor parte de los controladores integran un único convertidor, pero pueden tomar muestras de tensiones analógicas procedentes de diferentes patillas o “canales analógicos” de entrada. Tal y como se ve en la figura 7-3, en el caso de nuestro controlador Arduino NANO, disponemos de 8 de estas patillas numeradas como A0-A7, lo que nos permite recoger muestras analógicas de hasta 8 sensores diferentes. Figura 7-3. Canales analógicos de Arduino NANO

Mediante el uso de las funciones apropiadas podemos seleccionar en todo momento qué canal analógico queremos convertir. Únicamente se puede realizar la conversión de un canal cada vez. Observa la figura 7-4. Cada vez que ordenamos realizar una conversión, se toma una muestra de la tensión analógica presente en ese momento en el canal de entrada seleccionado. Arduino tarda unos 100 µS (0.0001 s.) en obtener el resultado binario equivalente, lo que permitiría realizar unas 10000 conversiones por segundo. Figura 7-4. Conversiones AD

7-2


Cuando se ordena realizar la conversión en el instante 1, la tensión analógica muestreada en ese momento es de 2.2 V aproximadamente. El convertidor generará como resultado un código o valor binario proporcional a esa tensión. En el instante 2, la tensión muestreada y su correspondiente valor binario proporcional, corresponde a una tensión de 2.8 V. En el instante 3 a 3.5 V, en el 4 a 4.2 V y, en el instante 10, a una tensión de 4.7 V. En la figura se aprecia que entre una conversión y otra transcurre un lapsus de 100 µS (0.0001 s.). Representa el tiempo mínimo que tarda Arduino NANO en hacer una conversión. Es un tiempo de conversión bastante aceptable si se trata de muestrear señales que varían con cierta rapidez en el tiempo. Por ejemplo, si como se muestra en la figura 7-5, disponemos de una señal analógica con una frecuencia F de 1000 Hz, su periodo T sería de 1000 µS (1 mS). Por lo tanto, podemos tomar 10 muestras de cada ciclo de esa señal (1000 µS / 100 µS). Figura 7-5. Muestreo de una señal de 1000 Hz Si tuviéramos una señal analógica cuya frecuencia F es de 500 Hz y su periodo T de 2000 µS, podremos hacer una total de 20 muestreos (2000 µS / 100 µS). Es decir, tendríamos una “digitalización” más precisa de esta nueva señal. No siempre es necesario tomar tantas muestras por segundo de una determinada señal analógica. Pensemos de nuevo en un sensor que mide la temperatura ambiente. Se trata de una magnitud que varía muy lentamente. La temperatura no pasa de -10 ºC a +15 ºC en 0.0001 segundos. Lo mismo pasa con la luz natural. No pasamos de la noche al día cada 100 µS. También ocurre con el peso. Nadie pesa 60 Kg ahora y 85 Kg 100 µS después. Por todo ello podemos afirmar: ¡¡ La velocidad de conversión de Arduino NANO es más que suficiente para medir la mayor parte de magnitudes físicas analógicas !! Además de la velocidad de conversión, otro factor a tener en cuenta en un convertidor es su “resolución” o precisión. En el caso del convertidor que integra Arduino NANO, se dice que tiene una resolución de 10 bits. Quiere decir que el resultado que ofrece tras una conversión puede tener 1024 valores digitales 10 posibles (2 ). Para establecer una relación entre el valor digital o binario de salida, y la tensión analógica de entrada que estamos midiendo, necesitamos conocer una constante llamada “Tensión de referencia” (VREF). Es la tensión que emplea el convertidor para hacer sus operaciones. La resolución por bit se calcula según la siguiente ecuación, y depende tanto de la VREF como del número de bits del convertidor. Suponiendo que VREF = 5 V:

ó =

=

= .

/

≅

= .

Conocido esto podemos predecir el valor binario de salida que nos ofrecerá el convertidor, en función de la tensión analógica de entrada que estamos midiendo. Observa y analiza la siguiente tabla:

TENSION 0.000 0.005 0.010 0.015 0.020 1.000 2.000

SALIDA BINARIO DEC. 0000000000 0 0000000001 1 0000000010 2 0000000011 3 0000000100 4 0011001100 204 0110011000 408

HEX. 0x0 0x1 0x2 0x3 0x4 0xCC 0x198

TENSION 2.500 3.000 4.000 4.985 4.990 4.995 5.00

SALIDA BINARIO DEC. 1000000000 512 1001100110 614 1100110011 819 1111111100 1020 1111111101 1021 1111111110 1022 1111111111 1023

HEX. 0x200 0x266 0x333 0x3FC 0x3FD 0x3FE 0x3FF

7-3


Basta dividir la tensión de entrada analógica entre la resolución por bit del convertidor, en este caso 0.00488. Por ejemplo: 3 V / 0.00488 = 614 = 0x266 = 1001100110. ¡¡ IMPORTANTE !!. La tensión analógica a medir nunca debe ser superior a la tensión de referencia VREF que emplea el convertidor en sus operaciones internas. Por ejemplo, si VREF = 5V la tensión analógica máxima de entrada será también de 5 V.

3.- FUNCIONES DEL LENGUAJE ARDUINO Para el control y empleo del convertidor ADC integrado en Arduino NANO únicamente se necesitan dos sentencias del lenguaje de programación Arduino. Son muy sencillas y seguro que les encuentras un sinfín de posibles aplicaciones. 3-1 Función: analogReference() Permite determinar la tensión de referencia (VREF) que va a emplear el convertidor ADC, para realizar la conversión de una tensión analógica en su equivalente valor digital o binario. Esto es importante ya que conocida ésta podremos calcular la resolución por bit del convertidor. La tensión VREF no debe ser mayor que la tensión general que alimenta al controlador Arduino NANO (normalmente 5 V). Por su parte, la tensión analógica que se desea convertir, no debe ser mayor que la tensión VREF. Sintaxis: analogReference(tipo); tipo:

Selecciona el tipo de VREF que va a emplear el convertidor: DEFAULT: Es la tensión de referencia por defecto. VREF es la misma que la tensión con la que se alimenta el controlador: 5 V o 3.3 V según el tipo de controlador. INTERNAL: Es una tensión de referencia fija que se genera en el interior del propio controlador. En el caso de Arduino NANO es de 1.1 V. EXTERNAL: Se usa como tensión VREF de referencia la aplicada por la patilla AREF del controlador.

Ejemplo: analogReference(INTERNAL);

//Se emplea una tensión de referencia de 1.1V

En este ejemplo, teniendo en cuenta que el convertidor es de 10 bits, la resolución por bit es de:

ó =

=

.

= .

/

≅

= .

3-2 Función: analogRead() Es la sentencia que vamos a emplear para realizar una conversión analógico/digital. Cada vez que se ejecuta toma una muestra de la tensión presente en el canal analógico indicado, y realiza la conversión de la misma. Sintaxis: analogRead(pin);

7-4


pin:

Es el número de la patilla correspondiente al canal analógico que deseamos convertir. En el caso de Arduino NANO son 8: A0-A7.

Ejemplo: int V; V=analogRead(A3);

//Realiza la conversión de la tensión presente en la patilla A3.

3-3 Función map() Esta sentencia no está relacionada exclusivamente con el convertidor analógico/digital. Se puede utilizar en muchos otros casos, pero viene muy bien en el que nos ocupa. La función nos permite remapear, reasignar o acotar un valor comprendido entre un mínimo y un máximo, en otro. Ya sabemos que el convertidor de nuestro Arduino tiene una resolución de 10 bits, por lo que el 10 resultado puede ser un valor numérico comprendido entre 0 y 1023 (2 ). Sin embargo, nos puede interesar 8 usar dicho valor como si fuera de 8 bits (byte), comprendido entre 0 y 255 (2 ), ya que es un formato mucho más estándar y más empleado por múltiples funciones. Sintaxis: map(valor, min, max, Nmin, Nmax); valor:

Es el valor que se desea reasignar. Normalmente es de tipo int (16 bits) o de tipo long (32 bits). No debe usarse con valores tipo float. min: Expresa el límite mínimo del valor actual. max: Expresa el límite máximo del valor actual. Nmin: Expresa el límite mínimo del nuevo valor. Nmax: Expresa el límite máximo del nuevo valor. Ejemplo: int V; V=readAnalog(A3); v=map(V,0,1023,0,255);

//Realiza la conversión de la tensión presente en la patilla A3 //Reasigna el valor leído convirtiéndolo a un byte

El valor analógico leído desde la patilla A3, está comprendido entre 0 y 1023 y se almacena en la variable V. Dicho valor se reasigna a otro equivalente comprendido entre 0 y 255. Esta sentencia, según Arduino, responde a la siguiente función matemática:

=

(

)∗(

− (

−

−

)

)+

4.- PERIFERICOS ANALOGICOS Ya se ha comentado que en el mercado existe una gran variedad de sensores y dispositivos capaces de proporcionar una tensión analógica, comprendida entre un mínimo y un máximo, en función de una determinada magnitud física. Para desarrollar las siguientes prácticas hemos elegido a tres de ellos por su facilidad de uso, por ser asequibles y fáciles de localizar.

7-5


4-1 El potenciómetro Se trata de una resistencia cuyo valor varía conforme movemos su eje, mando o “cursor”. Son los periféricos analógicos más económicos que puedes encontrar y pueden tener diferentes formas, tamaños y valores. Como se muestra en la figura 7-6, el entrenador Universal Trainer dispone de dos potenciómetros que podemos usar cuando nos interese. Uno de ellos tiene una resistencia total de 1 KΩ y el otro de 100 KΩ.

Figura 7-6. Potenciómetros en el Universal Trainer En la figura 7-7 puedes ver el aspecto de uno de estos potenciómetros así como su símbolo eléctrico. Dispone de tres terminales o patillas. La 1 y la 2 se corresponden con los extremos de la resistencia y representan el valor total de la misma. La patilla 3 es el cursor y está asociado mecánicamente con el eje o mando que permite deslizarlo por el cuerpo de la resistencia. Cada vez que lo movemos variamos el valor de la resistencia. Si lo colocamos justo en el centro de su recorrido, entre las patillas 1 y 3 tenemos la mitad de la resistencia total, en las patillas 2 y 3 la otra mitad. Por el mismo motivo se aplicamos una tensión en sus extremos 1 y 2, por ejemplo de 5 V, entre la patilla 3 y cualquiera de las otras dos tendremos una tensión que varía entre 0 y 5V en función de dónde coloquemos el cursor. Figura 7-7. Un potenciómetro 4-1-1 Ejemplo: Conversión_AD

ARDUINO NANO Tx

Veamos un primer ejemplo de conversión a digital o binario de una tensión analógica que se aplica por la patilla A0. Realiza el montaje del esquema de la figura 7-8. Los extremos del potenciómetro de 1K del entrenador Universal Trainer se conectan con GND y +5 VCC de alimentación. El cursor se conecta con el canal analógico de entrada de la patilla A0. Moviendo ese cursor de un extremo a otro estaremos aplicando una tensión analógica comprendida entre 0 y 5V. La conversión se realiza cada vez que se accione el pulsador E10 conectado con la patilla D2.

Interface USB Rx con el PC E10 CONVERTIR +5Vcc 1K

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

Figura 7-8. Conversión AD El programa espera a recibir un pulso procedente de la entrada digital D2. La única novedad en este ejemplo se encuentra en las siguientes dos funciones: AN0=analogRead(A0); V=AN0*0.00488;

//Realiza la conversión de A0 (potenciómetro) //Calcula la tensión equivalente

La función AN0=analogRead(A0) toma una muestra de la tensión analógica presente en la patilla A0, y que suministra el potenciómetro. El resultado digital se almacena en la variable “AN0”. A continuación se calcula la tensión real aplicada, como si fuera un voltímetro. Basta con multiplicar el valor digital por la constante 0.00488. Recuerda que esta constante representa la resolución por bit.

7-6


Finalmente, de la forma ya conocida, transmitimos el resultado vía serie al terminal del entorno Arduino. Lo hacemos en decimal, en binario, en hexadecimal y en voltios. En la figura 7-9 se ven una serie de medidas realizas. Con el potenciómetro en un extremo la tensión analógica aplicada es de 0V. En el extremo opuesto será de +5V. En medio puedes realizar múltiples medidas cuya tensión puedes contrastar con un voltímetro. Figura 7-9. Midiendo tensiones analógicas

4-1-2 Ejemplo: Umbrales Al disponer de un valor numérico representando a una tensión analógica, tenemos la posibilidad de realizar todo tipo de procesos y cálculos con él. En este ejemplo se trata de comparar la tensión analógica con dos valores: uno mínimo y otro máximo. Monta el circuito de la figura 7-10. El potenciómetro se conecta con el canal analógico de la patilla A0, el led S7 con la patilla D2 y el led S0 con la patilla D3. Si la tensión es igual o menor que la mínima establecida, se activa S7. Si es igual o mayor que la máxima, se activa S0. Si no está en ninguno de los dos rangos, ambos leds se desactivan.

Figura 7-10. Comparando una tensión

MINIMO S7 S0 MAXIMO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

+5Vcc

1K

ARDUINO NANO

4-1-3 Ejemplo: Comparador_Analógico Tx

Interface USB Rx con el PC S7

V1>V2

S4

V1=V2

S0

V1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

ARDUINO NANO

+5Vcc +5Vcc V2

100K

+5Vcc

V1

1K

Por supuesto que podemos utilizar dos o más canales analógicos. En este ejemplo se compara la tensión analógica V1 en la patilla A0, con la tensión analógica V2 en la patilla A1. Realiza el montaje de la figura 7-11. Las tensiones se introducen a través de los potenciómetros del entrenador. Si V1 > V2 se activa la salida D2 conectada con el led S7. Si V1 = V2 se activa la salida D3 conectada con el led S4. Por último, si V1 < V2 se activa la salida D4 conectada con el S0. Puedes usar un voltímetro para medir ambas tensiones V1 y V2 y comprobar el correcto funcionamiento del comparador analógico de tensiones.

Figura 7-11. Circuito comparador Es posible que notes que es francamente difícil ajustar ambas tensiones V1 y V2 a un mismo valor y que se active así el led S4 (V1=V2). Los convertidores suelen tener una precisión de ± 1 bit. Si además tenemos en cuenta que los potenciómetros son dispositivos electromecánicos, resultará muy difícil obtener dos conversiones idénticas. La igualdad en ambas tensiones V1 y V2 se aprecia perfectamente cuando los potenciómetros se mueven a ambos extremos (0V o 5V).

7-7


4-1-4 Ejemplo: Control_de_Brillo ¿Por qué no usar un valor analógico, tras su conversión a digital, como el parámetro de entrada para otras funciones? Es lo que proponemos en este ejemplo. La tensión analógica que se introduce a través de un potenciómetro, la vamos a emplear para regular el ciclo útil de una señal PWM con la que controlaremos el brillo de un led (o una bombilla, o la velocidad de giro de un motor, o la posición de un servo, etc…).

S0

Monta el circuito de la figura 7-12. El potenciómetro de 1K se conecta con la patilla de entrada analógica A0. El led S0 cuyo brillo vamos a regular se conecta con la patilla D3.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

+5Vcc

REG.

1K

ARDUINO NANO

Figura 7-12. Control de brillo

Como novedad en el ejemplo usamos la función map(). Se emplea para trasladar un número de un rango a otro rango diferente de forma proporcional. En este programa el valor obtenido de la conversión, que está en el rango comprendido entre 0 y 1023, se pasa a otro rango comprendido entre 0 y 255 con el que se genera la señal PWM. AN0=analogRead(A0); AN0=map(AN0,0,1023,0,255);

//Realiza la conversión de A0 //Reasigna el resultado entre 0 y 255

4-1-5 Ejemplo: Generador_BF

LS7

SPEAKER

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

+5Vcc

REG.

1K

ARDUINO NANO

De forma similar, también podemos ajustar, por ejemplo, la frecuencia de una señal. Monta el circuito de la figura 7-13. Se trata de un generador de frecuencias que puede tener un buen número de aplicaciones prácticas como la comprobación de amplificadores B.F. (Baja Frecuencia), equipos de audio, ecualizadores, etc… A partir del valor analógico que proporciona el potenciómetro de 1K conectado en la patilla A0, se genera una frecuencia audible comprendida entre 100 y 5000 Hz (5 KHz). Figura 7-13. El generador de BF

El programa es muy similar al anterior. Una vez realiza la conversión analógica, se obtiene un valor digital comprendido entre 0 y 1023. Se le mapea a un rango de 100 a 5000, que se corresponde con el rango deseado de las frecuencias de salida. También se verifica si la frecuencia seleccionada ha variado en ±50 Hz, en cuyo caso se transmite vía serie y se ajusta la nueva frecuencia. La figura 7-14 muestra la última frecuencia ajustada (1095 Hz) y la medida realizada por un osciloscopio conectado en D12.

Figura 7-14. La frecuencia de salida

7-8


4-2 El sensor de luz Se basa en un componente llamado “fototransistor”. Este dispositivo es capaz de dejar pasar a su través más o menos intensidad en función de la luz visible que incide sobre él. Es directamente proporcional. A más luz más intensidad y viceversa. Los hay de diferentes modelos. Algunos, como éste, son capaces de detectar la luz ambiente visible por el ojo humano. Otros detectan luz no visible como la infra-roja. La fotografía de la figura 7-15 muestra el aspecto del sensor modelo BPW40 que vamos a usar en los siguientes ejemplos. Consta de dos electrodos: el “Emisor” (E) y el “Colector” (C), que es la patilla más corta. Figura 7-15. El sensor BPW40

La figura 7-16 nos proporciona el símbolo del fototransistor BPW40 y su esquema de funcionamiento. Imagina que, mediante una linterna, haces incidir más o menos luz sobre el sensor. Con ello varías la intensidad (I) que lo recorre desde el emisor (E) al colector (C). Dicha intensidad al atravesar la resistencia (R), provoca una tensión (V) que también varía de forma proporcional: V = R * I. En resumidas cuentas, cuanta más luz incida sobre el sensor, mayor es la intensidad que lo recorre y mayor es también la tensión en la salida V. Esta varía entre los 0 V (a oscuras) y los 5 V (luz máxima). Figura 7-16. Funcionamiento del sensor BPW40 4-2-1 Ejemplo: Fotómetro Es el ejemplo más sencillo y realmente no aporta cosas nuevas respecto a todo lo visto hasta ahora. Monta el circuito del esquema de la figura 7-17.

Tx

Interface USB Rx con el PC MEDIR E10

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



ARDUINO NANO

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

El colector C (patilla corta) del BPW40 se conecta con +5Vcc y el emisor E con la patilla A0 del Arduino NANO y con un extremo de la resistencia de 10 KΩ. El otro extremo de la resistencia se conecta con GND. E

10K

C

BPW40

Cada vez que se pulsa E10 conectado con la patilla D2, se realiza una nueva medida.

+5Vcc

Figura 7-17. El fotómetro

El programa se limita a medir la tensión que genera el sensor BPW40 en función de la luz que incide cobre él. Transmite vía serie al terminal del entorno Arduino, el resultado de la conversión, la intensidad que circula por el sensor y la resistencia, y la caída de tensión en ésta. Trabajo personal Debes considerar a este ejemplo como un programa experimental. Puedes realizar varias medidas de referencia en diferentes condiciones de luz ambiente y tomar nota de ellas como en la figura 7-18. También puedes buscar una relación entre esas medidas y las proporcionadas por un instrumento comercial. A partir de ahí tú también puedes diseñar tu propio instrumento que mida la luz en luxes o en lúmenes. Figura 7-18. Muestras de medidas de luz

7-9


4-2-2 Ejemplo: Control_Alumbrado

S0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

Aquí tienes un ejemplo con una buena utilidad práctica. Se trata de controlar un sistema de alumbrado de forma que, cuando la luz ambiente baje por debajo de un valor mínimo (p.e. se hace de noche), se active una salida que simula la activación de una bombilla, farola, etc…

+5Vcc

Monta el circuito de la figura 7-19. El led S0 se conecta con la patilla D3 de salida. Simula la activación o no del sistema de alumbrado.

E 10K

ARDUINO NANO

C

BPW40

+5Vcc

Figura 7-19. Control de alumbrado

El ejemplo muestra cómo “filtrar” una señal analógica que, como en este caso, nos suministra el sensor de luz. Basta con tomar un número determinado de muestras haciendo las conversiones analógico/digitales que sean necesarias. Luego se calcula la media aritmética con todas ellas. Para realizar esta tarea se ha creado una función llamada Medir_luz(). Devuelve un valor entero con el valor medio de las 10 conversiones que se realizan con un intervalo de 2 mS entre muestra y muestra. Se comprueba si el valor medio obtenido es menor que el valor mínimo establecido, en cuyo caso se activa la salida D3 simulando el alumbrado. Trabajo personal Consideremos el control de alumbrado anterior. Es de noche y las farolas están activadas. ¿Qué pasa si en una noche de tormenta se produce un rayo o un relámpago cuya luz incide sobre el sensor? Seguramente las farolas se apagan ya que, en ese instante, el sistema piensa que es de día. Luego se volverán a encender. Esto es real y puede ocurrir, pero ¿es deseable? Encuentra una solución para corregir este tipo de casos. 4-2-3 Ejemplo: Regulación _de_Luz Estamos seguros de que se te van a ocurrir gran cantidad de aplicaciones basadas en la detección y tratamiento de la luz ambiente. Por ello te vamos a proponer un último ejemplo que, como todos los demás, es susceptible de ser mejorado. Se trata de un sistema automático para regular el alumbrado de, por ejemplo, un recinto. Imagina una habitación con una bombilla de alumbrado y un sensor de luz colocado estratégicamente en el exterior. Según la luz que reciba, la bombilla brillará más o menos. Cuando es un día claro y luminoso la bombilla permanece apagada o con muy poca intensidad. Si por el contrario es un día nublado, o es de noche, la bombilla brillará con mucha intensidad. Te sirve el mismo esquema que el de la figura 7-19 anterior. El programa es muy sencillo y como tal no aporta nada nuevo salvo la idea propia de la aplicación. Se realiza una conversión analógica/digital y se toma una muestra de la luz ambiente actual. Para ello empleamos la función Medir_luz() desarrollada en el ejemplo anterior. El valor obtenido estará comprendido entre 0 y 1023 y se mapea en otro valor comprendido entre 255 y 0 mediante: Luz=Medir_luz(); Luz=map(Luz,0,1023,255,0);

//Mide la luz ambiente //Redondear a un valor entre 255 y 0

Observa que si la luz medida es de 0 (oscuridad total), tras el mapeado tenemos el valor 255. Si se recibe la luz máxima, el valor de la conversión es de 1023 tras el mapeado tendremos el valor 0. Es decir, con poca luz tenemos un valor alto y viceversa.

7 - 10


Este valor mapeado es el que vamos a usar para generar una señal PWM por la patilla D3, y que controlará el brillo del led S0 (o la bombilla). Cuanto menor sea la luz ambiente (de noche), mayor es la duración del ciclo útil. El led se ilumina con más intensidad. Si la luz ambiente es mayor (de día), menor es la duración del ciclo útil. El led se ilumina con menos intensidad.

4-3 El sensor de temperatura En la fotografía de la figura 7-20 se muestra el sensor LM35DZ junto con la distribución de sus patillas. Se trata de un sensor analógico de temperatura.

Figura 7-20. El sensor LM35

La figura 7-21 muestra su esquema de conexiones. Tiene tres patillas. Dos de ellas se conectan con la alimentación, +5V y GND. Por la tercera patilla circula una intensidad (I) proporcional a la temperatura. Esta intensidad atraviesa la resistencia (R) creando en ella una tensión (Vout) que la aplicaremos a la entrada del convertidor analógico digital, desde donde la podremos leer y procesar. Así pues tenemos una tensión directamente proporcional a la temperatura del sensor. Según su fabricante, su resolución es de:

10 mv / ºC Figura 7-21. Conexiones del sensor de temperatura

Para calcular la temperatura ambiente en grados centígrados (ºC), a partir del resultado de la tensión Vout que suministra el sensor, podemos aplicar la siguiente ecuación:

×

=

4-3-1 Ejemplo: Temperatura

+5Vcc Tx

La salida Vout del sensor de temperatura se conecta con la patilla de entrada analógica A0. El resultado se transmite vía serie al terminal del entorno de programación de Arduino.


30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

tª GND

E10


Vdd

MEDIR

LM35DZ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

1

Siguiendo la línea de ejemplos anteriores, se trata de medir la temperatura que capta el sensor LM35 cada vez que se acciona el pulsador E10 conectado con la patilla D2. Ver el esquema de la figura 7-22.


Vout

×

3

×

2

º =

100K

ARDUINO NANO

Figura 7-22. Sensor de temperatura

7 - 11


La figura 7-23 muestra una ventana con diferentes capturas de las temperaturas medidas. En primer lugar se transmite el valor capturado por el convertidor analógico digital AN0, procedente del sensor. Luego se transmite la tensión equivalente V (AN0 * 0.00488) seguido de la intensidad I en µA (V / 100000 * 1000000 = V * 10). Por último se transmite la temperatura T en ºC (V / 10mV. Figura 7-23. Midiendo temperaturas

4-3-2 Ejemplo: Climatizador Acabamos el tema con otro ejemplo de una importante utilidad práctica. Vamos a simular un sencillo sistema de climatización. Monta el circuito de la figura 7-24.

S0 CALEFACTOR

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

tª GND


Vout


3

S7 REFRIGERADOR

LM35DZ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Vdd


2

El ejemplo toma la temperatura actual mediante el sensor analógico conectado con A0. Si sobrepasa unos límites máximos y mínimos se activa el sistema correspondiente. En cualquier caso, la temperatura actual, que se toma cada dos segundos, se transmite vía serie al terminal del entorno Arduino.

+5Vcc Tx

1

El led S7 simula la activación o no de un sistema de refrigeración, mientras que el led S0 simula a un sistema de calefacción. Ambos se conectan con las patillas D2 y D3 respectivamente.

100K

ARDUINO NANO

Figura 7-24. Sistema de climatización

7 - 12

ARDUINO: La tecnología al alcance de todos TEMA 8: La pantalla LCD www.microcontroladores.com

TEMA 8: LA pantalla LCD 1.- INTRODUCCIÓN Vamos a acabar este módulo de prácticas presentando una serie de ejemplos adicionales que, esperamos, puedan tener una valiosa utilidad práctica, te sirvan definitivamente para asentar todo lo aprendido hasta el momento y te proporcionen una visión de las múltiples aplicaciones que puedes realizar con un controlador como nuestro Arduino NANO. Queremos hacer una mención especial a la pantalla LCD que vamos a emplear. Sobre ella vamos a poder visualizar todo tipo de información. En realidad, todos aquellos ejemplos que hemos realizado, y cuyos resultados se trasmitían vía serie al PC, podemos visualizarlos ahora sobre la pantalla LCD. Esto nos permitirá realizar aplicaciones totalmente autónomas e independientes.

2.- LA PANTALLA LCD Se trata de uno de los periféricos más potentes y versátiles. Es capaz de visualizar todo tipo de mensajes compuestos de texto, números y símbolos, y producir además diferentes efectos de visualización como desplazamientos a izquierda y derecha, parpadeos, scrolls, etc… Una pantalla LCD tiene su propio controlador que la gestiona. La figura 8-1 muestra la pantalla LCD que vamos a utilizar y que se incluye en el módulo. Se trata de una pantalla compuesta de 2 filas y 16 caracteres por fila (2x16). Las hay con diferentes configuraciones: 1 x 16, 4 x 20, 2 x 20, 2 x 40, etc… En la figura también se aprecia cómo hemos soldado una tira de 14 pines macho, que nos permitará insertar la pantalla sobre el módulo board del entrenador Universal Trainer. De esta forma podremos hacer rápidamente las conexiones con el controlador. Observa la posición en que se encuentra la patilla número 1.

Figura 8-2. Conexiones de una pantalla LCD NOMBRE GND VCC VLC

Nº 1 2 3

RS

4

R/W

5

E

6

D0:D7

7 – 14

7 8 9 10 11 12 13 14 D0 D1 D2 D3 D4 D5 D6 D7

4 5 6 RS R/W E

La figura 8-2 muestra el conexionado típico de estas pantallas. Normalmente disponen de 14 patillas que se describen en la siguiente tabla. También las hay de 16 patillas. En este caso las dos últimas, la 15 y la 16, permiten controlar una luz de fondo.

GND VCC VLC

1 2 3

Figura 8-1. La pantalla LCD de 2 x 16

LCD2x16

DESCRIPCION Conexión con GND de alimentación Conexión con +5 V de alimentación Tensión variable de entrada de entre 0 y 5 V para ajustar el contraste de la pantalla. Entrada de control. A nivel “1” la pantalla recibe los códigos ASCII de los caracteres a visualizar. A nivel “0” recibe códigos de control. Entrada de lectura / escritura. A nivel “1” podemos leer el estado interno de la pantalla. A nivel “0” podemos escribir los distintos caracteres a visualizar o los distintos códigos de control. A nivel “1” la pantalla queda habilitada para recibir caracteres y/o códigos de control. A nivel “0” queda desconectada. Son las líneas de datos por donde la pantalla recibe los caracteres y/o códigos de control. Se conectan con las salidas de nuestro controlador. El interface puede ser de 8 bits (se emplean a D0:D7) o de 4 bits (se emplean a D4:D7)

8-1


7 8 9 10 11 12 13 14 D0 D1 D2 D3 D4 D5 D6 D7

4 5 6 RS R/W E

GND VCC VLC

1 2 3

4K7

+5Vcc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

La figura 8-3 muestra las conexiones que vamos a realizar entre la pantalla LCD y el controlador Arduino NANO. Se realiza un interface de 4 bits. Las patillas D4:D7 del Arduino se conectan con las patillas D4:D7 de la pantalla. Las patillas D2 y D3 controla las señales RS y E. La señal R/W se manda directamente a GND (modo escritura).

ARDUINO NANO

Con la resistencia de 4K7 conectada entre VLC y GND se consigue un buen contraste. Su valor se puede variar para aumentarlo o disminuirlo.

LCD2x16

Figura 8-3. Conexión de Arduino con la pantalla LCD La fotografía de la figura 8-4 muestra el montaje final sobre el entrenador Universal Trainer.

Figura 8-4. Montaje de la pantalla LCD

3.- FUNCIONES PARA EL CONTROL DE UN LCD Ya estamos familiarizados con el concepto de “librería” y el manejo de las múltiples funciones que contiene. Acuérdate de la librería “Servo.h” que usamos en su momento para el control de servomotores. De las muchas librerías creadas por el equipo de Arduino, vamos a hablar ahora de la librería “LiquidCrystal.h”. Contiene un buen número de funciones dedicadas al control y manejo de pantallas LCD basadas en el controlador Hitachi HD44780 o compatible.

8-2


De todas esas funciones, vamos a estudiar las más representativas e importantes. En cualquier caso, te invitamos a que visites el sitio www.arduino.cc donde encontrarás abundante información y ejemplos con todas ellas. 3-1 Función: LiquidCrystal() Crea una variable tipo LiquidCrystal y establece las conexiones entre la pantalla y el controlador Arduino. El interface entre ambos puede ser de 8 o de 4 bits, en cuyo caso las líneas D0-D3 no se emplean. Igualmente podemos determinar si se emplea o no la señal R/W de la pantalla. En caso de no usarse, dicha señal debe conectarse con GND. Sintaxis: LiquidCrystal var(RS,E,D4,D5,D6,D7); LiquidCrystal var(RS,RW,E,D4,D5,D6,D7); LiquidCrystal var(RS,E,D0,D1,D2,D3,D4,D5,D6,D7); LiquidCrystal var(RS,RW,E,D0,D1,D2,D3,D4,D5,D6,D7); var: RS: RW: E: D0-D7:

//Para interface de 4 bits sin señal R/W //Para interface de 4 bits con señal R/W //Interface de 8 bits sin señal R/W //Interface de 8 bits con señal R/W

Nombre de una variable que se asigna a la pantalla LCD que vamos a controlar. Patilla del Arduino que se conecta con la señal RS de la pantalla. Patilla del Arduino que se conecta con la señal R/W de la pantalla (si es que se va a usar). Patilla del Arduino que se conecta con la señal E de la pantalla. Patillas de Arduino que se conectan con las líneas de datos D0-D7 de la pantalla. Si no se indican las patillas para D0-D3, se supone un interface de 4 bits y únicamente se emplean las señales D4-D7.

Ejemplo: LiquidCrystal lcd(2,3,4,5,6,7);

//Establece la conexión de una pantalla llamada “lcd”. Las patillas D2 a D7 del //Arduino se conectan con las señales RS,E,D4,D5,D6 y D7 de la pantalla. La //señal R/W se debe conectar con GND

3-2 Función: begin() Inicia la pantalla LCD y le asigna el número de filas y el número de caracteres por fila según el modelo de que se trate. En nuestro caso usamos una pantalla de 16 x 2 caracteres. Sintaxis: var.begin(c,f); var: c: f:

Es el nombre que define a la pantalla en cuestión (establecido en LyquidCrystal()). Número de columnas. Número de filas.

Ejemplo: LiquidCrystal lcd(2,3,4,5,6,7); lcd.begin(16,2);

//La pantalla “lcd” es de 16 x 2

3-3 Función setCursor() Coloca el cursor de la pantalla LCD en la posición deseada. A partir de ella se irán visualizando los posteriores caracteres. Sintaxis: var.setCursor(c,f);

8-3


var: c: f:

Es el nombre que define a la pantalla en cuestión (establecido en LyquidCrystal()). Número de columna (contando desde 0). Número de fila (contando desde 0).

Ejemplo: LiquidCrystal lcd(2,3,4,5,6,7); lcd.setCursor(3,0);

//Coloca el cursor en la posición 3 (4º carácter) de la fila 0 (la 1ª)

3-4 Función: home() Coloca el cursor en la primera posición de la pantalla, el ángulo superior izquierdo (posición 0 de la fila 0). No se borra el contenido de la misma. Sintaxis: var.home(); var:

Es el nombre que define a la pantalla en cuestión (establecido en LyquidCrystal()).

3-5 Función: clear() Borra la pantalla LCD y coloca el cursor en el ángulo superior izquierdo (posición 0 de la fila 0). Sintaxis: var.clear(); var:


Ejemplo: LiquidCrystal lcd(2,3,4,5,6,7); lcd.clear();

//Borra la pantalla

3-6 Función: write() Escribe un carácter en la posición actual del cursor. Sintaxis: var.write(char); var: char:

Es el nombre que define a la pantalla en cuestión (establecido en LyquidCrystal()). El carácter a visualizar

Ejemplo: lcd.write(‘A’);

//Escribe ‘A’

3-7 Función: print() Imprime sobre el LCD a partir de la posición actual del cursor. Sintaxis: var.print(dato); var.print(dato,base);

8-4


var: dato: base:

Es el nombre que define a la pantalla en cuestión (establecido en LyquidCrystal()). Dato a imprimir. Puede ser char, int, long, float o string. Es opcional y expresa la base de numeración deseada: BIN=Binario; DEC=Decimal (por defecto); OCT=Octal; HEX=Hexadecimal; o N=nº de decimales en el caso de los float (por defecto 2).

Ejemplos: int A=19; float PI=3.1416; lcd.print(A,HEX); lcd.print(“Hola”); lcd.print(PI*2,4);

//Imprime A en hexadecimal (1910 = 1316) //Imprime “Hola” //Imprime 6.2832

3-8 Función: cursor() Visualiza el cursor representándolo en la pantalla LCD en forma de un guión bajo ( _ ) en su posición actual, donde se escribirá el siguiente carácter. Sintaxis: var.cursor(); var:


3-9 Función: noCursor() Oculta la visualización del cursor de la pantalla LCD. Sintaxis: var.noCursor(); var:


3-10 Función: blink() Visualiza el cursor representándolo en la pantalla como un símbolo sólido ( ▓ ) intermitente en su posición actual, donde se escribirá el siguiente carácter. Sintaxis: var.blink(); var:


3-11 Función: noBlink() Oculta la visualización del cursor sólido ( ▓ ) intermitente. Sintaxis: var.noBlink(); var:


3-12 Función noDisplay() Apaga la pantalla LCD sin perder ni el texto que hubiera ni la posición actual del cursor.

8-5


Sintaxis: var.noDisplay(); var:


3-13 Función: display() Conecta el LCD restaurando el texto que hubiera antes de ejecutar noDisplay(). Sintaxis: var.display(); var:


3-14 Función scrollDisplayLeft() Desplaza el contenido que visualiza la pantalla (texto y posición del cursor) una posición a la izquierda. Sintaxis: var.scrollDisplayLeft(); var:


3-15 Función scrollDisplayRight() Desplaza el contenido que visualiza la pantalla (texto y posición del cursor) una posición a la derecha. Sintaxis: var.scrollDisplayRight(); var:


3-16 Función: leftToRight() Establece la dirección de escritura de izquierda a derecha sobre la pantalla (por defecto). Esto implica que los caracteres se van escribiendo de izquierda a derecha sin afectar a los que ya están escritos. Sintaxis: var.LeftToRight(); var:


3-17 Función: rightToLeft() Establece la dirección de escritura de derecha a izquierda sobre la pantalla. Esto implica que los caracteres se van escribiendo de derecha a izquierda sin afectar a los que ya están escritos. Sintaxis: var.RightToLeft(); var:


8-6


3-18 Función autoscroll() Activa el scroll o desplazamiento automático de la visualización. Cada carácter enviado a la pantalla se visualiza y a continuación se desplaza una posición a los caracteres que ya hubiera en ella. Si la dirección actual es de izquierda a derecha (leftToRight()), la visualización se desplaza hacia la izquierda. Si la dirección actual es de derecha a izquierda (rifghtToLeft()), la visualización se desplaza hacia la derecha. Sintaxis: var.autoscroll(); var:


3-19 Función noAutoscroll() Desactiva el scroll o desplazamiento automático de la visualización. Sintaxis: var.noAutoscroll(); var:


3-20 Función: createChar() Crea un carácter personalizado por el usuario. Se pueden crear un total de 8 caracteres de 5 x 8 pixels y numerados del 0 al 7. La apariencia o diseño de un carácter se determina en una matriz de 8 bytes, uno por cada fila. Los 5 bits de menos peso de cada byte se corresponden con los 5 pixels que forman cada fila del carácter. Una vez creado un carácter, se puede visualizar en la pantalla indicando simplemente su número. Sintaxis: var.createChar(n,dato); var: n: dato:

Es el nombre que define a la pantalla en cuestión (establecido en LyquidCrystal()). Expresa el número del carácter en cuestión (del 0 al 7). Es el nombre de la matriz que contiene los bytes que definen el carácter personalizado.

Ejemplo: byte flecha[8] ={ B00100, B01110, B10101, B00100, B00100, B00100, B00100, B00100 };

//Crea la matriz “flecha” con 8 bytes que definen el nuevo carácter personalizado

lcd.createChar(0,flecha); …. lcd.write(byte(0));

//Crea el nuevo carácter nº 0 con el contenido definido en “flecha” //Visualiza el carácter personalizado nº 0 (la flecha)

8-7


4.- EJEMPLOS DE CONTROL DE UNA PANTALLA LCD En este apartado vamos a presentar una serie de ejemplos que utilizan las funciones anteriores, con objeto de controlar la pantalla LCD y realizar diferentes efectos de visualización. La mayor parte de ellos se han realizado a partir de los ejemplos incluidos en Arduino, no sin antes modificarlos y adaptarlos a nuestras condiciones. Para probarlos, y salvo que se indique otra cosa, vamos a emplear el esquema de conexiones que se mostró en la figura 8-3. 4-1 Ejemplo: HolaMundo

Es el más sencillo. Se realizan las tareas más básicas como incluir la librería “LiquidCrystal.h” y definir, mediante LiquidCrystal(), las conexiones entre el Arduino y la pantalla LCD que, en nuestro caso, se corresponden con el esquema de la figura 8-3. Por último, mediante la función begin(), se inicia la pantalla LCD indicando el número de caracteres y de filas de que consta (16 x 2). El resultado de la ejecución de este programa se aprecia en la fotografía de la figura 8-5. Básicamente se limita a emplear la función print() para escribir cualquier texto y setCursor() para posicionar el cursor de la pantalla a partir de la posición que se desea escribir. Figura 8-5. Ejemplo “Hola, mundo!” 4-2 Ejemplo: Display Emplea las funciones display() y noDisplay() para habilitar o no la pantalla LCD. Cuando se deshabilita la pantalla se apaga, pero su información se mantiene. De esta forma, cuando se vuelve a habilitar la pantalla visualiza exactamente lo mismo que tenía. 4-3 Ejemplo: Cursor Las funciones cursor() y noCursor() permite activar o no la visualización del cursor. El cursor se presenta como el símbolo de un guión bajo ( _ ) y en todo momento indica la posición donde se visualizará el siguiente carácter que escribamos en la pantalla. 4-4 Ejemplo: Blink El cursor también se puede representar como un símbolo sólido ( ▓ ) intermitente, que indica la posición donde se visualizará el siguiente carácter que escribamos en la pantalla. Para ello podemos emplear las funciones blink() y noBlink(). 4-5 Ejemplo: DireccionTexto Mediante las funciones leftToRight() y rightToLeft() podemos establecer si el texto se visualiza de izquierda a derecha según lo vamos escribiendo, o bien de derecha a izquierda. Por defecto la pantalla, al igual de cómo lo hacemos nosotros, visualiza el texto de izquierda a derecha. El ejemplo escribe un mismo texto “Microsystems” en las dos líneas que dispone la pantalla LCD. En la línea superior se escribe de izquierda a derecha, lo normal. En la línea inferior se escribe de derecha a izquierda.

8-8


4-6 Ejemplo: Scroll Cada vez que se ejecutan las sentencias scrollDisplayLeft() o scrollDisplayRight(), el contenido actualmente visualizado en la pantalla se desplaza una posición a la izquierda o a la derecha respectivamente. El programa del ejemplo ofrece unos bonitos efectos de presentación. Visualiza dos textos en ambas líneas de la pantalla LCD, luego los desplaza a la izquierda, a la derecha y de nuevo a la izquierda. Finaliza haciendo una secuencia de intermitencia. 4-7 Ejemplo: Autoscroll Mediante las funciones autoscroll() y noAutoscroll() se habilita o no el desplazamiento automático. Este consiste en desplazar la visualización una posición cada vez que se escribe un nuevo carácter en la pantalla. El desplazamiento puede ser hacia la izquierda o hacia la derecha. Si la dirección del texto está ajustada de izquierda a derecha mediante la función leftToRight() (por defecto), se produce un desplazamiento a la izquierda. Si la dirección del texto está ajustada de derecha a izquierda mediante la función rightToLeft(), se produce un desplazamiento automático a la derecha. El ejemplo visualiza dos textos, uno en cada línea de la pantalla. En la línea superior se visualiza sin desplazamiento, en la línea inferior se visualiza con un desplazamiento automático hacia la izquierda (por defecto). 4-8 Ejemplo: CaracteresPersonalizados La mayor parte de las pantallas LCD compatibles con el controlador Hitachi HD44780 permiten diseñar o personalizar hasta un máximo de 8 caracteres numerados del 0 al 7. De esta forma podemos construir símbolos gráficos o incluso caracteres de un determinado idioma que no están definidos en la propia pantalla. Cada carácter se construye en torno a una matriz de 5x8 pixels o puntos, por lo que se necesitan los 5 bits de menos peso de 8 bytes consecutivos. En la figura 8-6 tenemos el diseño de dos caracteres: una sonrisa y un corazón. Cada uno de ellos precisa de 8 bytes que se codifican según se muestra. Un bit a nivel “1” implica que su correspondiente pixel se activa.

Figura 8-6. Diseño de caracteres personalizados El programa crea cinco matrices o arrays de 8 bytes cada una, donde se definen otros tantos caracteres personalizados: “corazon”, “alegre”, “serio”, “abajo” y “arriba”. Mediante la función createChat() se numeran (del 0 al 4) y se almacenan en la memoria interna de la pantalla. Por último, para visualizarlos en la posición actual del cursor, basta con emplear la función write(n), donde n expresa el número de carácter (del 0 al 4 en el ejemplo) que se desea visualizar. 4-9 Ejemplo: SerialDisplay Aquí tienes un ejemplo de indudable interés práctico. Se trata de crear un nexo de unión entre el canal serie de, por ejemplo, un ordenador tipo PC, y nuestra pantalla LCD. En medio se encuentra nuestro controlador Arduino NANO. Monta el circuito de la figura 8-7.

8-9

ARDUINO: La tecnología al alcance de todos TEMA 8: La pantalla LCD www.microcontroladores.com Tx


7 8 9 10 11 12 13 14 D0 D1 D2 D3 D4 D5 D6 D7

4 5 6 RS R/W E

GND VCC VLC

1 2 3

4K7

+5Vcc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



ARDUINO NANO

LCD2x16

30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

+5Vcc

El Arduino hace de puente. Por un lado se conecta, mediante el interface USB con un PC. Por otro lado se conecta con la pantalla LCD como lo hemos venido haciendo hasta ahora. Desde el PC vamos a transmitir una serie de mensajes que serán recibidos por el Arduino. Este a su vez los trasmitirá a la pantalla LCD.

Figura 8-7. Comunicación PC / LCD

En el PC podemos emplear cualquier programa de comunicaciones como el “Hyperterminal”, o bien el propio monitor serie que integra el entorno de trabajo de Arduino. Es el que hemos usado nosotros. La figura 88 muestra el resultado de la ejecución. Desde el PC transmitimos el mensaje “Hola, que tal ?” que se visualiza en la pantalla LCD.

Figura 8-8. Ejemplo de comunicación 5.- TRABAJO PERSONAL Llegamos al final del presente módulo de prácticas. Como trabajo personal te proponemos que modifiques aquellos ejemplos en los que se usaba la comunicación serie para recibir los distintos resultados que se obtenían en la ejecución. Ahora ya sabes manejar una pantalla LCD. Se trata de un periférico de salida muy potente y versátil capaz de visualizar cualquier cosa. No te hace falta un ordenador tipo PC que reciba los resultados que se obtienen en las diferentes aplicaciones. Ahora puedes emplear la pantalla para visualizarlos. Con ello conseguirás aplicaciones mucho más autónomas, portátiles y económicas.

8 - 10

Manual de Usuario Modulo 8

Recommend Documents