Mi Arduino Uno tiene un BLOG

Display de 4 dígitos y 7 segmentos con controlador TM1637

noreply@blogger.com (Mariano del Campo) — Fri, 23 Nov 2018 16:55:00 +0000

Hoy os traigo un fantástico POST en el que os voy a enseñar como poder visualizar datos a través de un display de 4 dígitos y 7 segmentos con controlador TM1637 utilizando la librería “TM1637.h”, que se encuentra dentro de la carpeta “TM1637_DigitalTube” que se puede descargar del siguiente enlace, dotada de los recursos y funciones suficientes para simplificar nuestro trabajo de manera importante y poder así mostrar a través del display números tanto positivos como negativos y algunas letras como A, b, C, d, E y F. En el mercado existen displays de este tipo en diferentes colores (blanco, azul, verde, rojo y amarillo), por un precio entorno a los 2-3€.

Display de 4 dígitos y 7 segmentos con controlador TM1637

Un display de 7 segmentos de 4 dígitos tradicional tiene 12 pines. Este módulo incluye un chip TM1637 para reducir a 2 los pines para controlar los 4 dígitos. Esto quiere decir que, con solo 2 pines digitales se controla tanto el valor mostrado en el display como la iluminación del mismo.

Este display 7 segmentos tiene dos hilos para alimentación, GND y VCC (que puede ser 5V o 3.3V), y dos pines de datos (CLK y DIO) que podemos conectar a los pines digitales de Arduino que queramos. En este POST vamos a conectar el display según se muestra a continuación:

Tabla de conexiones display de 4 dígitos TM1637

Lista de Materiales:

Arduino UNO Rev.3.
Cable USB tipo A-B.
Un display de 4 dígitos y 7 segmentos con controlador TM1637.
Cables de conexión.

Programa:

Descarga del programa

Video:

Programación de un Arduino UNO a través de ICSP

noreply@blogger.com (Mariano del Campo) — Mon, 12 Jun 2017 16:47:00 +0000

En este POST voy a explicar cómo programar un Arduino UNO a través de ICSP, que no es más que un método de programación serie en circuito que se realiza mediante un conector de 6 pines (MOSI, MISO, SCK, RESET, VCC y GND ) que nuestra placa Arduino tiene para tal fin, teniendo acceso a la memoria de programa (Flash) del microcontrolador AVR (Atmega328) y poderle grabar directamente desde el PC el Bootloader, que es un gestor de arranque interno necesario para que nuestro Arduino se pueda comunicar correctamente con el IDE, o cargarle cualquiera de los programas (Sketchs) que nos interesen, sin necesidad de utilizar el puerto USB de nuestro Arduino.

Conector ICSP en un Arduino UNO

Para poder hacer uso de este método de programación va a ser necesario un hardware adicional denominado programador. En nuestro caso vamos a utilizar como programador ICSP un Arduino UNO, un USBTinty y un USBasp, aunque también existan otros métodos alternativos a los citados.

1º MÉTODO ICSP: Arduino UNO como programador ICSP.

Para este método de programación ICSP vamos a necesitar inicialmente un Arduino UNO configurado como programador ICSP. Para ello le debemos de cargarle un “Sketch” especial que viene en el IDE de Arduino, dirigiéndonos hacia el menú “Archivo à Ejemplos à ArduinoISP”, como se muestra en la siguiente imagen:

Ruta del programa “ArduinoISP” que incluye el IDE de Arduino

A continuación se nos abrirá el programa que debemos de cargar en el Arduino UNO que vamos a utilizar como programador ICSP, como si de cualquier programa se tratara, es decir, conectando el Arduino UNO al PC a través del puerto USB, seleccionando la placa Arduino UNO y el puerto COM en el que conectamos el Arduino UNO, y por último, presionando el icono subir (Ctrl + U).

Programa “ArduinoISP” que incluye el IDE de Arduino

Una vez cargado el programa correctamente en el Arduino UNO que vamos a utilizar como programador ICSP, debemos de realizar la conexión ICSP entre los dos Arduinos como se muestra en la siguiente tabla:

Conexiones para la programación ICSP entre los dos Arduinos UNO

Una vez conectados los dos Arduinos mediante ICSP, conectamos el Arduino UNO programador ICSP al USB de nuestro PC y abrimos el IDE de Arduino para cargar el Bootloader o el programa que queramos al otro Arduino a través de él. Para ello debemos de tener configurado el IDE de Arduino como se muestra a continuación, teniendo muy presente que tenemos que seleccionar el puerto COM en el que tengamos conectado nuestro Arduino programador ICSP.

Configuración del IDE de Arduino para programación con Arduino ICSP

Para finalizar debemos de abrir el programa que deseamos cargar en nuestro Arduino y dirigirnos hacia el menú ”Archivo à Subir Usando Programador” para poder subir el programa correctamente a la placa. Si deseamos cargar el “Bootloader” en la placa, simplemente pulsamos la opción “Quemar Bootloader” en el menú de Herramientas.

Menú ”Archivo” del IDE de Arduino

Lista de Materiales:

· 2 Arduino UNO Rev.3.

· IDE 1.6.4 de Arduino (vale cualquier otra versión).

· Cable USB tipo A-B.

· Cables de conexiones.

2º MÉTODO ICSP: Programador ICSP “USBTinty”

Para poder utilizar este método de programación ICSP vamos a necesitar un programador ICSP denominado comercialmente como “USBTinty”.

Programador ICSP “USBTiny”

Lo primero que tendremos que hacer es conectarlo al puerto USB de nuestro PC y posteriormente cargarle los driver como si de cualquier otro HARDWARE se tratase, es decir, entrando en el administrador de dispositivos si estamos trabajando con un sistema operativo Windows. En el siguiente enlace podéis obtener los drivers actualizados.

Una vez que nuestro PC haya reconocido y configurado para su uso el programador “USBTinty”, tendremos que conectar el bus de 6 pines que trae el programador a nuestro Arduino como se muestra a continuación y no de cualquier otra manera, aunque podemos realizar la conexión ICSP entre el programador y el Arduino “pin a pin” siempre que respetemos el orden de conexiones ICSP que el “USBTinty” trae serigrafiado en su parte posterior.

Conexión entre el “USBTinty” y nuestro Arduino UNO

A continuación tenemos que conectar el “USBTiny” al puerto USB de nuestro PC y abrir el IDE de Arduino para configurarlo como se muestra en la siguiente imagen.

Configuración del IDE de Arduino para programación ICSP con “USBTiny”

Como podemos observar, tenemos que seleccionar el puerto COM donde está conectado el USBTiny, el tipo de placa a programar, que en nuestro caso es un Arduino UNO y además debemos de seleccionar el USBTinyISP como programador. Para quemar el Bootloader, que es el Firmware de arranque de la placa, simplemente presionaríamos la opción realizándose el proceso automáticamente.

Por último, para cargar un programa a la placa a través del USBTiny, presionaríamos la opción “Subir usando Programador” del menú “Archivo” del IDE de la misma manera que lo hemos hecho para el primer método ICSP.

Lista de Materiales:

· Arduino UNO Rev.3.

· Programador ICSP “USBTinty”.

· Drivers “USBTinty”.

· IDE 1.6.4 de Arduino (vale cualquier otra versión).

· Cable USB tipo A-B.

· Cables de conexiones (Cable de 6 pines opcional)

3º MÉTODO ICSP: Programador ICSP “USBasp”

Para poder trabajar con este último método de programación ICSP vamos a necesitar un programador ICSP llamado “USBasp”.

Programador ICSP “USBasp”

Antes de comenzar os tengo que avisar de que este método es el más tedioso y complicado de configurar por lo que no os lo recomiendo si podemos utilizar alguno de los dos anteriores, puesto que además de instalar los drivers correspondientes es necesario actualizar el firmware del “USBasp” para que pueda ser reconocido por el IDE de Arduino. Para ello vamos a seguir una serie de pasos que a continuación os detallo.

Para comenzar vamos a conectar el “USBasp” a nuestro PC a través del puerto USB para que lo reconozca y podamos instalar los drivers correspondientes como si de cualquier otro dispositivo “Hardware” se tratara. En este enlace os dejo los drivers actualizados y funcionando correctamente.

Una vez que tengamos los drivers instalados, vamos a pasar a actualizar el firmware del “USBasp”, para ello, vamos a necesitar un Arduino UNO configurado como programador ICSP, como os he explicado en el primer método de este POST, además de tener instalado el software “AVRDUDESS 2.4” que podéis descargar desde aquí. Antes de continuar con la conexión entre el “USBasp” y el Arduino UNO configurado como programador ICSP, debemos de abrir el “USBasp” y puentear mediante un Jumper o cablecito los dos orificios que trae en su parte posterior, para que pueda ser programado (una vez programado hay que retirarlo para que “USBasp” funcione correctamente).

Jumper de programación en el “USBasp”

Las conexiones a realizar entre el Arduino UNO configurado como programador ICSP y el “USBasp” son las que se muestran en la siguiente tabla:

Tabla de conexiones entre el Arduino Uno configurado como programador ICSP y el USBasp

Configuración de los pines en el programador “USBasp”

Por último, una vez realizadas las oportunas conexiones, vamos a descargar de aquí el nuevo firmware para poder cargárselo al “USBasp” a través del software “AVRDUDESS 2.4” que hemos instalado anteriormente, para ello, una vez abierto el software tenemos que realizar las siguientes operaciones:

A. Programador à Arduino.

B. Atmega8 MCU (suponiendo que el USBasp tiene un atmega8).

C. Puerto COM à Elegimos el puerto donde está conectado el Arduino Uno configurado como programador ICSP.

D. Velocidad en baudios de la comunicación à19200.

E. Seleccionamos el archivo firmware que hemos descargado anteriormente.

F. Presionar el botón “Program!”.

Configuración del software “AVRDUDESS 2.4”

Una vez actualizado el “USBasp” ya podrá ser reconocido por el IDE de Arduino para poder programar un Arduino Uno a través de él. Para ello debemos de conectar los pines ICSP del Arduino a programar a los pines del “USBasp”, respetando las conexiones “pin a pin”, para posteriormente conectar el “USBasp” al puerto USB de nuestro PC, abrir el IDE de Arduino y configurarlo como a continuación se muestra.

Configuración del IDE de Arduino para programación ICSP con “USBasp”

Para ello abrimos el programa que queremos cargar en el Arduino UNO, seleccionamos la placa Arduino UNO y el puerto “COM” donde conectamos el “USBasp”, y por último, tenemos que seleccionar el “USBasp” como programador. Si queremos “Quemar el Bootloader” simplemente pulsaríamos en la opción y se realizaría automáticamente en pocos segundos. Para cargar el programa nos tenemos que ir al menú “Archivo à Subir Usando Programador” como se ha venido haciendo en los métodos ICSP anteriormente explicados.

Lista de Materiales:

· Arduino UNO Rev.3.

· Programador ICSP “USBasp”.

· Drivers “USBasp”.

· IDE 1.6.4 de Arduino (vale cualquier otra versión).

· Software “AVRDUDESS 2.4”.

· Firmware “USBasp”.

· Cable USB tipo A-B.

· Cables de conexiones (Cable de 10 pines opcional).

Composición de colores RGB con potenciómetros a través de Bluetooth

noreply@blogger.com (Mariano del Campo) — Wed, 22 Feb 2017 11:49:00 +0000

Con este POST vamos a ser capaces de realizar la composición de cualquier color en un LED RGB mediante 3 potenciómetros, uno para cada color (Rojo, Verde y Azul), tal y como se analizó en un POST anterior, pero esta vez, lo haremos a través de comunicación bluetooth entre dos Arduinos, es decir, en vez de conectar tanto el LED RGB como los tres potenciómetros de control del color RGB al mismo Arduino, conectaremos el LED RGB al “Arduino Esclavo”, que va a ser el encargado de recibir a través de bluetooth los valores R, G y B necesarios para componer el color, además de aplicárselos al LED RGB para que los ejecute, y por otra parte conectaremos los tres potenciómetros al “Arduino Maestro” que va a ser el encargado de leer el valor analógico de los mismos y de transformarlos para poder enviarlos a través de bluetooth hacia el “Arduino Esclavo”.

Comunicación Bluetooth “Maestro-Esclavo” entre dos Arduinos

Para poder realizar la comunicación bluetooth entre los dos Arduinos, necesitaremos conectar un módulo bluetooth HC-06 al “Arduino Esclavo” para que pueda recibir los valores R, G y B de la composición del color y además necesitaremos conectar un módulo bluetooth HC-05 al “Arduino Maestro” configurándolo como maestro para que pueda enviar los valores R, G y B a través de bluetooth. Debemos de tener en cuenta que para que ambos Arduinos se sincronicen vía bluetooth deben de tener configurado mediante “comandos AT” el mismo pin de conexión, que en mi caso es “1234” en ambos Arduinos y también la misma velocidad de transmisión (os recomiendo 38400 Baudios para no tener que modificar los programas que cargamos en los Arduinos), para ello, tenemos el siguiente POST, donde se explica con detenimiento cómo configurar estos módulos bluetooth con éxito.

Tabla de conexiones

Cabe aclarar que tanto la masa (GND) como la alimentación (VCC) de los módulos bluetooth HC-05 y HC-06 van conectadas respectivamente a los pines “GND” y “+5V” de Arduino. Los potenciómetros lineales de 10KΩ tienen un mando de control y tres terminales de conexión que denominaremos P1, P2 y P3, donde P2 es el terminal central del potenciómetro. Como necesitamos tres potenciómetros en este proyecto, vamos a utilizar la matriz de enteros “const int Pot[3] = {0, 1, 2}” para definir a que pines analógicos de Arduino van a ir conectados los terminales centrales de los potenciómetros para poder realizar la lectura de sus valores, lo que significa que el terminal central del potenciómetro que regula el color rojo del LED RGB (P2_Pot[0]) va conectado a la entrada analógica “A0” de Arduino, el que regula el color verde (P2_Pot[1]) le conectaremos a la entrada analógica “A1” y el que regula el color azul (P2_Pot[2]) le conectaremos a la entrada analógica “A2”. Los otros dos terminales, P1 y P3, de cada uno de los tres potenciómetros van conectados respectivamente a los pines +5V y GND de Arduino. Por último, tengo que explicar, que el módulo RGB consta de cuatro pines de conexión, tres de ellos para los valores de entrada R, G y B que van conectados a los pines digitales 9, 10 y 11 respectivamente, y el restante que va conectado al pin “GND” de Arduino.

Para finalizar tengo añadir que para que todo esto funcione correctamente simplemente debemos de realizar correctamente la conexión de todos los componentes, a la vez que cargar el código correspondiente en cada uno de los Arduinos para que se comporten de manera adecuada. Una vez realizado esto, debemos de tener alimentados los dos Arduinos y esperar a que sincronicen los módulos bluetooth entre sí para comenzar a operar. Esto es un proceso automático y no es necesario realizar ninguna tarea adicional para que ocurra, sabiendo que están sincronizados cuando el LED de conexión de los módulos bluetooth HC-06 y HC-05 deje de parpadear para permanecer en un estado fijo. A partir de aquí podremos ir moviendo el mando de control de los 3 potenciómetros (R, G y B) para ir componiendo los colores en el LED RGB. Si abrimos el monitor serie del “Arduino Maestro” cuando lo tenemos conectado al PC a través del cable USB, podremos ver el valor de R, G y B (de 0 a 255) que estamos enviando a través de Bluetooth en cada momento cuando movemos los mandos de los tres potenciómetros.

Monitor serie

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Módulo Bluetooth HC-05 (Maestro).

· Módulo Bluetooth HC-06 (Esclavo).

· LED RGB de 5mm (cátodo común).

· 3 Resistencias de 220Ω.

· 3 Potenciómetros lineales de 10KΩ.

· Protoboard.

· Cables de conexión.

NOTA: Si utilizamos un módulo RGB, no nos hace falta utilizar ni el LED RGB ni las resistencias, puesto que ya viene todo integrado en una pequeña placa.

Código del programa:

· Arduino Esclavo

Descarga del programa para el “Arduino Esclavo”

· Arduino Maestro

Descarga del programa para el “Arduino Maestro”

Video:

Control del brillo de una bombilla mediante un Dimmer AC y Bluetooth

noreply@blogger.com (Mariano del Campo) — Fri, 13 Jan 2017 15:54:00 +0000

Gracias a este POST vamos a aprender a controlar el brillo de una bombilla convencional de 220VAC mediante un Dimmer AC, como ya hicimos en un POST anterior, aunque en este caso vamos a modificar o variar el pulso PWM, que controla el Dimmer AC, desde una APP Android a través de Bluetooth y no desde el monitor serie como ya vimos con anterioridad. Ahora bien, para que nuestro Arduino pueda recibir el valor del PWM a través de Bluetooth tenemos que añadirle a nuestro proyecto un módulo Bluetooth HC-05, descrito y configurado en este POST, aunque lo debemos de conectar a nuestro Arduino como se muestra en la siguiente tabla. Cabe recordaros que la velocidad de comunicación (BAUDIOS) configurada mediante comandos AT del módulo Bluetooth HC-05, que en mi caso son 38400 bps (por defecto), debe coincidir con la velocidad de comunicación serie para el módulo Bluetooth que incluimos dentro de la programación que cargaremos a nuestro Arduino UNO (BT.begin(38400);).

Tabla de conexiones entre nuestro Arduino y el módulo HC-05

Como ya sabemos de un POST anterior, un Dimmer AC es un atenuador de intensidad capaz de regular los 220VAC de su entrada para que su salida ofrezca un valor de 220VAC o inferior, que es donde conectaremos la bombilla para así poder controlar su brillo variando el pulso PWM entregado a través de Bluetooth. A continuación os muestro una tabla donde se relaciona directamente el valor de la señal PWM con el porcentaje de atenuación del Dimmer y el porcentaje de brillo de la bombilla.

Diagrama de funcionamiento del Dimmer AC

Como se puede observar en el diagrama anterior, la atenuación del valor de la entrada del Dimmer AC respecto de su salida es inversamente proporcional al brillo de la bombilla, es decir, a mayor atenuación de los 220VAC de la entrada del Dimmer AC obtenemos menor voltaje en la salida del mismo (menor brillo de la bombilla) y viceversa. A continuación os muestro las conexiones que debemos realizar en el Dimmer AC para que nuestro sistema funcione tal y como se ha descrito.

Tabla de conexiones del Dimmer AC

Una vez realizadas las oportunas conexiones de todo el sistema lo primero que tenemos que hacer es compilar y cargar el programa que tenemos en la descarga, en nuestro Arduino, para posteriormente instalar la aplicación "1 Channel Dimmer Bluetooth " que nos podemos descargar del siguiente enlace. Para instalar la APP en nuestro Smartphone, simplemente descomprimimos la carpeta descargada y copiamos el archivo “1CH_Dimmer_Bluetooth.apk” dentro de la tarjeta SD, para posteriormente abrir el explorador de archivos de nuestro Smartphone, buscar la ruta del archivo copiado y ejecutar el archivo dándole todos los permisos que sean necesarios para su instalación.

Aplicación Android “1 Channel Dimmer Bluetooth”

Una vez instalada la aplicación debemos de realizar una serie de procesos como se muestra en el siguiente vídeo para poder vincular y conectar el módulo Bluetooth HC-05 a nuestro Smartphone y así poder utilizar la aplicación para enviar el valor del PWM mediante Bluetooth.

Si pulsamos el botón “ON” de la APP se envía a través de Bluetooth el valor “90” (Bombilla completamente encendida) y si por el contrario pulsamos el botón “OFF” se envía el valor “14” (Bombilla completamente apagada). Para valores intermedios del pulso PWM (entre 14 y 90), es decir, para variar el brillo de la bombilla, tenemos que ir pulsando sobre la barra central y nunca arrastrar el marcador, puesto que si lo hacemos, el sistema quedará bloqueado necesitando un reinicio para volver a su funcionamiento normal. Si el valor enviado a través de la APP es superior a 90 es considerado por el Dimmer AC en todos los casos como 90, gracias a la programación que le cargamos a nuestro Arduino, y si es inferior a 14 es considerado siempre como 14. Para poder observar el valor del PWM que le estamos mandando al Dimmer AC a través de la APP en cada momento simplemente tendremos que abrir el monitor serie del IDE de Arduino como ya lo hemos realizado en múltiples ocasiones y comenzar a enviar valores PWM desde la APP.

Monitor serie

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Dimmer AC (50Hz/220V).

· Módulo Bluetooth HC-05.

· Casquillo portalámparas de PVC.

· Bombilla de 28W/220VAC (vale cualquier bombilla de 220VAC).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del programa

Panel luminoso de Matrices LED 8x8 controlado mediante Bluetooth

noreply@blogger.com (Mariano del Campo) — Wed, 21 Dec 2016 17:42:00 +0000

En este POST aprenderemos a controlar mediante Bluetooth un panel luminoso compuesto por 4 matrices LED 8X8, es decir, lo que haremos en cuestión será mostrar un mensaje de texto en forma de bucle desplazándose de derecha a izquierda (Scroll horizontal) dentro de las 4 matrices LED 8x8 que conectaremos en cascada. Estos mensajes que vamos a visualizar en el panel los podemos enviar a través de Bluetooth desde un PC o desde un Smartphone con sistema operativo Android, aunque los que tengáis un sistema operativo iOS lo podréis realizar de una manera similar aunque no se incluya en este POST. No os voy a hablar más sobre la conexión, el funcionamiento y las características de las matrices LED 8X8 porque ya se explicó en otro POST, ahora bien, para que nuestro Arduino pueda recibir los mensajes a través de Bluetooth necesitamos añadirle el módulo Bluetooth HC-06 descrito y configurado justamente en el POST anterior, aunque lo debemos de conectar a nuestro Arduino como se muestra en la siguiente tabla.

Tabla de conexiones entre nuestro Arduino y el módulo HC-06

Una vez realizadas las oportunas conexiones de todo el sistema lo primero que tenemos que hacer es compilar y cargar el programa que tenemos en la descarga, en nuestro Arduino, puesto que es válido para cualquiera de los dos métodos de envío de mensajes de texto (ASCII) a través de Bluetooth que se van a analizar en este POST. A continuación os describo detalladamente cada uno de los dos métodos de los que disponemos para interactuar a través de Bluetooth con nuestro Arduino junto con el módulo HC-06.

Envío de mensajes mediante Bluetooth desde un PC

Como ya os anticipaba con anterioridad, uno de los dos métodos que vamos a poder utilizar para enviar mensajes de texto a través de Bluetooth hacia el módulo HC-06 está basado en la utilización de un PC que tenga este tipo de comunicación o añadiéndole a nuestro PC un “Dongle Bluetooth”, que no es más ni menos que un completo y compacto HARDWARE “Plug and Play” que conectaremos en nuestro PC a través del puerto USB para que se pueda comunicar mediante Bluetooth con otros dispositivos que posean este tipo de protocolo de comunicación.

Dongle Bluetooth

Para poder vincular y conectar el módulo HC-06 a nuestro PC a través de Bluetooth vamos a utilizar el software “BlueSoleil”, mediante el cual crearemos una conexión Bluetooth entre el PC y el módulo HC-06, asignándole un puerto serie del PC (COM) a dicha conexión. Posteriormente, para el envío de los mensajes de texto a través del puerto serie creado, vamos a utilizar el software “Octoplus Terminal”, que es un entorno gráfico muy simple de configurar y utilizar, que nos facilita enormemente dicha tarea. A continuación os dejo los enlaces de descarga de todo el software necesario así como un video donde se detalla todo el proceso de configuración y funcionamiento del sistema.

Descarga del Software "BlueSoleil" || Descarga del Software "Octoplus Terminal"

Envío de mensajes mediante Bluetooth desde un Smartphone

El segundo método que nos permite el envío de mensajes Bluetooth hacia el módulo HC-06 se basa en utilizar un Smartphone, puesto que están dotados de fábrica de este tipo de comunicación. Para ello debemos de instalar la aplicación "Bluetooth Terminal HC-05" desde la propia PLAY STORE del Smartphone o desde el siguiente enlace.

Aplicación Android Bluetooth Terminal HC-05

Una vez instalada la aplicación debemos de realizar una serie de procesos para vincular y conectar el módulo Bluetooth HC-06 al Smartphone y así poder utilizar la aplicación para enviar mensajes de texto (ASCII) mediante Bluetooth. A continuación os dejo el video donde se detalla todo el procedimiento a realizar.

Lista de Materiales:

Arduino UNO Rev.3.

Cable USB tipo A-B.

Módulo Bluetooth HC-06.

PC con Bluetooth o Dongle Bluetooth.

Smartphone con S.O Android.

Panel luminoso compuesto por 4 Matrices LED 8x8.

Fuente de alimentación de 5VDC/3000mA (opcional).

Protoboard.

Cables de conexión.

Código del programa:

Descarga del programa

Configurar módulos Bluetooth HC-05 y HC-06 mediante comandos AT

noreply@blogger.com (Mariano del Campo) — Tue, 13 Dec 2016 16:03:00 +0000

Hoy os voy a mostrar cómo configurar módulos Bluetooth HC-05 y HC-06 mediante comandos AT para poder trabajar con ellos en nuestros proyectos junto con ARDUINO UNO, es decir, para que se pueda comunicar nuestro ARDUINO con un PC, con un SMARTPHONE o para poder comunicar dos ARDUINOS de manera inalámbrica. Sin más preámbulos vamos a proceder a configurar estos compactos y sencillos dispositivos.

Logotipo del dispositivo Bluetooth

Bluetooth es una especificación industrial para Redes Inalámbricas de Área Personal (WPAN) que posibilita la transmisión de voz y datos entre diferentes dispositivos mediante un enlace por radiofrecuencia en la banda ISM de los 2.4 GHz. La especificación de Bluetooth define un canal de comunicación a un máximo 720 kbit/s (1 Mbit/s de capacidad bruta) con rango óptimo de 10 metros (opcionalmente 100 metros con repetidores). La potencia de salida para transmitir a una distancia máxima de 10 metros es de 0 dBm (1 mW), mientras que la versión de largo alcance transmite entre 20 y 30 dBm (entre 100 mW y 1 W). Los principales objetivos que se pretenden conseguir con esta norma son:

· Facilitar las comunicaciones entre equipos móviles.

· Eliminar los cables y conectores entre estos.

· Ofrecer la posibilidad de crear pequeñas redes inalámbricas y facilitar la sincronización de datos entre equipos personales.

Los dispositivos que con mayor frecuencia utilizan esta tecnología pertenecen a sectores de las telecomunicaciones y la informática personal, como PDA, teléfonos móviles, computadoras portátiles, ordenadores personales, impresoras o cámaras digitales. Existen multitud de módulos Bluetooth en el mercado que podemos utilizar junto con ARDUINO u otros microprocesadores, pero los más utilizados son los módulos de “JY-MCU”, puesto que son pequeños, compactos, de bajo consumo energético, muy económicos y por supuesto fáciles de encontrar en el mercado. Existen dos modelos de módulos Bluetooth: el “HC-05” que puede trabajar como maestro/esclavo y el “HC-06” que solo puede actuar como esclavo. La diferencia entre maestro y esclavo es que en modo esclavo es el dispositivo quien se conecta al módulo, mientras que en modo maestro es el módulo quien se conecta con un dispositivo u otro módulo.

Módulos Bluetooth JY-MCU

Físicamente, los dos módulos son muy parecidos, y la mejor manera de diferenciarlos es por los pines de E/S que nos ofrecen, es decir, 4 para el HC-06 y 6 pines para el HC-05. A continuación os describo la función de cada uno de los pines y su correspondiente conexión con los pines de ARDUINO:

· VCC: Alimentación del módulo entre 3,6V y 6V.

· GND: Masa del módulo.

· TXD: Pin para la transmisión de datos.

· RXD: Pin para la recepción de datos. Trabaja a un voltaje de 3,3V, aunque la mayoría de módulos ya trae conversor de niveles lógicos integrado, con lo que lo podemos conectar directamente al pin TX de Arduino (5V) sin tener que recurrir a HARDWARE externo para bajar el voltaje.

· EN: Pin para entrar en el modo de configuración del módulo (solo en el modelo HC-05).

· STATE: Pin de estado (salida) para conectar un led y visualizar cuando se está comunicando el módulo (solo en el modelo HC-05).

Tabla de conexiones de los módulos Bluetooth JY-MCU

Como podemos observar no existen diferencias HARDWARE significativas entre ambos modelos, pero sí que las hay en cuanto al FIRMWARE, es decir, en cuanto a la programación interna del módulo, por lo que mientras que el módulo HC-06 entra en el modo de programación (comandos AT) siempre que lo enciendes y no esté conectado a él ningún dispositivo mediante Bluetooth, el HC-05 es ligeramente más complicado de colocar en modo comandos AT y requiere de un modo de arranque específico que veremos más adelante.

Una vez aclarados los conceptos básicos para poder diferenciar los dos modelos de módulo Bluetooth, voy a profundizar en la configuración de cada uno de ellos, para ello primero debemos de conocer que son los “comandos AT” propiamente dichos. Los comandos AT son un tipo de comandos que sirven para configurar el módulo Bluetooth a través de un microcontrolador, un ordenador o con cualquier dispositivo que posea una comunicación serie (TX/RX), en nuestro caso, vamos a utilizar el monitor serie del IDE de ARDUINO para meter a través de comunicación serie estos comandos dentro de los módulos Bluetooth y que estos nos envíen una respuesta de estado a través del mismo monitor serie. Para entenderlo mejor, se puede decir, que los comandos AT son unas instrucciones que nos permiten cambiar por ejemplo la velocidad de comunicación del módulo (BAUDIOS), el código de emparejamiento (PIN), el nombre, etc. Para poder utilizar los comandos AT, el módulo Bluetooth no debe estar vinculado a ningún dispositivo (led rojo del módulo parpadeando). Es importante comprender, que en cuanto conectemos algún dispositivo a nuestro módulo Bluetooth, la luz roja dejará de parpadear y automáticamente saldremos del modo de comandos AT para entrar en el de transporte de información, es decir, cualquier cosa que le enviemos, incluyendo comandos AT, se considerara texto plano que se reenviará al otro extremo de la conexión Bluetooth (recordad que solo podemos enviar comandos AT mientras no estemos conectados a otros dispositivos Bluetooth).

MÓDULO BLUETOOTH HC-06

El módulo Bluetooth HC-06 viene configurado de fábrica como esclavo y no se puede cambiar, pero otras características si las podemos configurar utilizando comandos AT. Algunos de los valores predeterminados, de fábrica, más importantes que trae este módulo se resumen a continuación:

· Nombre: “linvor” o “HC-06”.

· Código de emparejamiento por defecto (PIN): 1234.

· Velocidad de comunicación (baud rate): 9600 bps (siempre que lo modifiquemos también lo tenemos que modificar dentro del programa para que se pueda comunicar correctamente).

· Configuración de paridad en la comunicación: Sin paridad.

Cabe destacar que el módulo HC-06 tiene dos estados los cuales es importante conocer:

· Modo comandos AT:

o El módulo entra a este modo tan pronto como lo alimentas y cuando no se ha establecido una conexión Bluetooth con ningún otro dispositivo.

o EL LED del módulo permanece parpadeando (frecuencia de parpadeo del LED es de 102ms).

o En este modo es cuando se debe enviar los comandos AT, en el supuesto de que se quiera configurar. Si se envían otros datos diferentes a los comandos AT el módulo HC-06 los ignorará.

· Modo Conectado:

o El módulo entra a este modo cuando se establece una conexión con otro dispositivo Bluetooth.

o El LED permanece encendido (sin parpadear).

o Todos los datos que se ingresen al módulo HC-06 por el Pin RX, se trasmiten por Bluetooth al dispositivo conectado, y los datos recibidos se devuelven por el pin TX. La comunicación es transparente.

o En este modo el módulo HC-06 no puede interpretar los comandos AT.

Ahora vamos a configurar el módulo Bluetooth HC-06 a través de comandos AT enviados desde el Monitor Serie del IDE de ARDUINO. Una vez compilado y cargado el código “Comandos_AT_ HC-06” en nuestro Arduino, abrimos el Monitor Serie.

Al enviar un comando AT no se debe enviar ningún carácter de LF (nueva línea) ni CR (retorno de carro) al final del comando. En el Monitor Serie del IDE de Arduino tenemos que poner “Sin ajuste de línea”, escribimos el comando “AT”, siempre con letras mayúsculas, y pulsamos ENVIAR para comprobar que la comunicación es correcta. Como se puede observar en la imagen vemos que el módulo Bluetooth nos responde con un OK.

Monitor serie al enviar el comando “AT” en módulo HC-06

Ahora únicamente vamos a modificar el nombre del módulo insertando el comando “AT+NAMEArduino_HC-06”, respondiéndonos el módulo HC-06 a través del monitor serie con “OKsetname”. Los demás parámetros los vamos a dejar como nos vienen por defecto de fábrica. A continuación os dejo una tabla con los comandos AT más utilizados para el módulo HC-06.

Tabla de comandos AT para el módulo Bluetooth HC-06

MÓDULO BLUETOOTH HC-05

Como se ha mencionado ya anteriormente, este módulo a diferencia del HC-06, requiere de un proceso específico para entrar en el modo de comandos AT, es decir, necesita que estemos presionando el botón que trae módulo cuando abrimos el monitor serie del IDE de Arduino, para que entre en el modo de comandos AT, puesto que necesita tener el pin “EN” activado a nivel alto (HIGH) antes de que el módulo comience a funcionar.

El módulo Bluetooth HC-05 viene configurado de fábrica con los siguientes valores predeterminados, aunque les podemos cambiar en cualquier momento mediante comandos AT.

· Nombre del módulo: “H-C-2010-06-01” o "HC-05" (Se puede modificar pero no nos responde con el nombre).

· Pin o contraseña: 1234 (+PSWD:1234).

· Modo de trabajo: Modo Esclavo (+ROLE:0).

· Modo de conexión: Se conecta al módulo Bluetooth especificado (+CMOD:0).

· Velocidad de transmisión: 38400 bps; Bit de parada: 1 bit; Bit de paridad: Sin paridad (+UART:38400,0,0).

Cabe destacar que el módulo HC-05 tiene tres estados los cuales es importante conocer:

· Modo comandos AT:

o El módulo entra en este modo de funcionamiento si mantenemos presionando el botón que trae mientras abrimos el monitor serie y cuando no se ha establecido una conexión Bluetooth con ningún otro dispositivo.

o EL LED del módulo permanece parpadeando (frecuencia de parpadeo del LED es de 2 segundos).

o En este modo es cuando se debe enviar los comandos AT, en el supuesto de que se quiera configurar. Si se envían otros datos diferentes a los comandos AT el módulo HC-05 los ignorará.

· Modo Conectado:

o El módulo entra a este modo cuando se establece una conexión con otro dispositivo Bluetooth.

o El LED permanece encendido (sin parpadear).

o Todos los datos que se ingresen al módulo HC-05 por el Pin RX, se trasmiten por Bluetooth al dispositivo conectado, y los datos recibidos se devuelven por el pin TX. La comunicación es transparente.

o En este modo el módulo HC-05 no puede interpretar los comandos AT.

· Modo Desconectado:

o El módulo permanece inactivo, es decir, ni emite ni recibe datos y el LED parpadea con una frecuencia de 102ms.

Ahora vamos a configurar el módulo Bluetooth HC-05 a través de comandos AT enviados desde el Monitor Serie del IDE de ARDUINO. Una vez compilado y cargado el código “Comandos_AT_ HC-05” en nuestro Arduino, abrimos el Monitor Serie, siempre manteniendo presionado el botón que trae el módulo.

A diferencia del módulo HC-06, al enviar un comando AT desde el monitor serie, este módulo espera que la línea acabe en “\r\n” y entonces es cuando ejecuta el comando AT. En el Monitor Serie de IDE de Arduino tenemos que poner “Ambos NL&CR” para terminar las líneas , escribimos el comando “AT”, aunque este módulo no distingue entre mayúsculas y minúsculas, y pulsamos ENVIAR para comprobar que la comunicación es correcta. Como se puede observar en la imagen vemos que el módulo Bluetooth nos responde con un OK.

Monitor serie al enviar el comando “AT” en módulo HC-05

Ahora únicamente vamos a modificar el nombre del módulo insertando el comando “AT+NAME=Arduino_HC-05”, respondiéndonos el módulo HC-05 a través del monitor serie con “OK”. Los demás parámetros los vamos a dejar como nos vienen por defecto de fábrica. A continuación os dejo una tabla con los comandos AT más utilizados para el módulo HC-05.

Tabla de comandos AT para el módulo Bluetooth HC-05.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Módulo Bluetooth HC-06.

· Módulo Bluetooth HC-05.

· Protoboard.

· Cables de conexión.

Código del programa:

• Comandos_AT_ HC-06:

Descarga del programa para el módulo Bluetooth HC-06

• Comandos_AT_ HC-05:

Descarga del programa para el módulo Bluetooth HC-05

Batería electrónica MIDI con Pro Tools 10 y EZ Drummer

noreply@blogger.com (Mariano del Campo) — Tue, 22 Nov 2016 17:01:00 +0000

Gracias a este POST seremos capaces de construir nuestra propia batería electrónica MIDI, basándonos en la placa ARDUINO UNO, que se comunicará a través del puerto USB con el software “Pro Tools 10”, para reproducir sonidos reales de batería gracias al “Plugin” EZ Drummer, para poder crear nuestras propias bases o nuestros propios temas como si de una batería electrónica se tratase. Como es un proyecto algo complejo y extenso lo voy a dividir en dos partes, la parte correspondiente al HARDWARE necesario para simular la batería física, es decir, los PADS y pedales que accionaremos, y la parte SOFTWARE correspondiente tanto a la instalación de los programas necesarios como del código que tendremos que cargar en nuestro ARDUINO UNO para que con cada golpe que demos en los PADS o cada vez que pisemos los pedales suenen los tambores, platos y el bombo de la batería virtual del EZ Drummer. Sin más demora comenzamos con todo este reto.

HARDWARE

La parte más importante de este proyecto, sin duda, es la creación de los PADS de la batería, que no es más ni menos donde vamos a golpear para generar una señal capaz de estimular nuestro ARDUINO y que este actúe en consecuencia a través de su programación interna para ejecutar sonidos mediante SOFTWARE. Para ello utilizaremos sensores piezoeléctricos como sensores de golpe, es decir, cada vez que los hagamos vibrar con un golpe, estos generarán una señal eléctrica entre sus dos terminales que podrá ser leída por ARDUINO a través de sus entradas analógicas.

Sensor piezoeléctrico

Los piezoeléctricos están polarizados, así que hay que conectarlos correctamente, es decir, el terminal positivo que es el que va soldado a la parte central del piezo lo conectaremos a la entrada analógica de ARDUINO que le corresponda y el terminal negativo que es el que va soldado a la parte externa del piezo lo conectaremos siempre a la masa de ARDUINO (GND). Entre los dos terminales del piezo es necesario conectar en paralelo una resistencia de 1 MΩ para limitar el voltaje y corriente generados por el sensor y proteger así la entrada analógica de ARDUINO donde va conectado cada uno. A continuación os muestro la correcta instalación de dichos sensores piezoeléctricos a nuestro ARDUINO.

Diagrama de conexión de los sensores piezoeléctricos

Como nuestro ARDUINO UNO solamente posee 6 entradas analógicas, solo podremos conectar un máximo de 6 PADS para nuestra batería, lo que nos limita el número de tambores y platos a simular, para posteriormente enlazarlos mediante SOFTWARE a la batería virtual dentro del EZ Drummer. Para realizar una estructura mucho más compacta a la hora de golpear los sensores piezoeléctricos, tendremos que pegarlos con cola de contacto, en alguna superficie circular de mayor tamaño y que pueda vibrar también al golpearla. Yo he optado por utilizar un tupperware circular de plástico, aunque esta parte es a libre elección de cada uno. También, para dar una mayor vistosidad a nuestros PADS, he añadido 6 LEDS alrededor de cada tupperware, que se iluminarán cada vez que golpeemos en el PAD correspondiente. Estos LEDS simplemente irán conectados en serie, es decir, el pin de masa (pata más corta) de cada uno de los LED lo conectaremos a masa (GND) a través de una resistencia de 220Ω para limitar la corriente que lo atraviesa para no quemarlo, y el otro pin (pata más larga) de cada uno de los LEDS irá conectado al pin digital de ADUINO programado para encender y apagar los LEDS del PAD correspondiente. Se conectan 6 LEDS por cada PAD por el motivo de que ARDUINO es capaz de generar la suficiente corriente en un pin digital como para encender todos al mismo tiempo cada vez que golpeamos en el PAD correspondiente sin tener problemas de alimentación. Muy importante a tener en cuenta es que el PAD 1 se compone del PIEZO 1 y del grupo de LEDS 1 dentro del tupperware de plástico.

Diagrama de conexión de los LEDS para cada PAD

Por último y para amortiguar los golpes en la tapa y que esta suene lo menos posible a “plástico” al golpearla, he añadido una pieza de goma EVA (Etilvinilacetato) en la parte superior de cada PAD. Al final de todo el proceso nos tiene que quedar todo integrado dentro de cada tupperware, obteniéndose tres salidas o cables por cada PAD, un cable que tendremos que conectar a la masa de ARDUINO (GND), puesto que la masa para el piezoeléctrico y para los LEDS es la misma, otro cable que conectaremos a la entrada analógica de ARDUINO correspondiente y el tercero que conectaremos al pin digital que maneja los LEDS de cada PAD. A continuación se muestra cómo quedaría cada uno de los 6 PADS.

PAD correctamente finalizado

Para finalizar con la fabricación e instalación de la parte física de la batería (HARDWARE), vamos a ver cómo crear y conectar los dos pedales necesarios (Charles y bombo), además de conectar un pulsador para el control del “doble bombo” y dos LEDS para avisarnos del estado tanto del bombo como del plato Charles en cada momento. La construcción de los pedales simplemente la vamos a realizar con un pulsador de timbre convencional que cortaremos en ángulo de 30 grados para acomodarlo a la base, un trozo de madera que utilizaremos como base del pedal, donde fijaremos el pulsador de timbre para su correcta sujeción cuando lo apoyemos en el suelo y por supuesto cable para su conexión a nuestro ARDUINO. A continuación os muestro el resultado final de cómo nos tiene que quedar cada uno de los dos pedales.

Pedal para Charles y para Bombo

También remarcar que tanto el pedal del plato Charles como el del bombo son idénticos en su estructura física, además ambos irán conectados a entradas digitales de ARDUINO mediante conexión PULL DOWN con una resistencia de 10KΩ, pero dentro de la programación van a tener tareas distintas como era de esperar. Como ya os anticipaba anteriormente tendremos que conectar también un pulsador, de la misma manera que los pedales (PULL DOWN con resistencia de 10KΩ), a uno de los pines digitales de ARDUINO, que cuando sea presionado será el encargado de cambiar la función de “bombo simple” a “doble bombo” del pedal del bombo, y para saber en todo momento en que MODO de los dos nos encontramos se encenderá un LED conectado a través de una resistencia de 220Ω, para limitar la corriente que lo atraviesa, a otro pin digital de ARDUINO cuando estemos en “doble bombo” permaneciendo apagado cuando ejecutemos el “bombo simple”. Para rematar esta parte también tenemos otro LED conectado a un nuevo pin digital de ARDUINO, limitado en corriente mediante una resistencia de 220Ω, para indicarnos cuando estamos pisando (LED encendido) o no (LED apagado) el pedal del Charles en cada momento para que, mediante programación y SOFTWARE, suene a “Charles cerrado” cuando pisamos el pedal o a “Charles abierto” cuando el pedal se encuentra en reposo. A continuación os muestro todo el diagrama de conexión de todos estos últimos periféricos que vamos a añadir a nuestra batería.

Diagrama de conexión de los pedales y señalización de FUNCIONES

Para recordar todas las conexiones de la batería a nuestro ARDUINO a continuación os dejo una tabla de conexiones detallada, además de una imagen de cómo os tienen que quedar los 6 PADS de la batería. Las conexiones de todos los elementos de este proyecto las podéis realizar a través de una PROTOBOARD o crear vuestra placa de circuito impreso (PCB) que podamos conectar a nuestra batería a modo “PLUG AND PLAY”, cosa muy recomendable, para no tener que estar montando todo desde el principio cada vez que utilicemos nuestra batería electrónica y que no haya falsos contactos entre los componentes.

Tabla de conexiones del HARDWARE de la batería electrónica

A continuación os muestro la imagen final de cómo nos debe de quedar nuestra batería electrónica si nos decidimos a utilizar los tupperware redondos como PADS.

Batería electrónica MIDI completa

SOFTWARE

La parte SOFTWARE es bastante más compleja que la HARDWARE, aunque no os preocupéis demasiado puesto que no vamos a profundizar en exceso en el tema, simplemente nos vamos a limitar a instalar el SOFTWARE necesario para que la batería suene y cargar el programa a nuestro ARDUINO para que ejerza de interface entre el HARDWARE creado y el SOFTWARE instalado. Lo primero que vamos a hacer es instalar el programa “Pro Tools 10.3.7” para posteriormente añadirle el “Plugin” EZ Drummer. Este software es funcional en S.O Windows 7 y en adelante, aunque para aquellos usuarios que utilicen MAC OS o LINUX tendrán que buscarse la manera de obtener el SOFTWARE. A continuación les dejo los enlaces para la descarga, dentro de los cuales vienen todos los archivos y explicaciones necesarias para la correcta instalación de todo esto.

Descarga de Pro Tools 10 --- Descarga de EZ Drummer

Una vez que tengamos instalados tanto el Pro Tools como el “Plugin” EZ Drummer, continuaremos instalando el LoopBe1 Monitor, que nos es más ni menos que un dispositivo MIDI interno (puerto MIDI Virtual) para transferir datos MIDI entre programas de computadora. Básicamente LoopBe1 es un "cable invisible" para conectar un puerto de salida MIDI de una aplicación a la entrada MIDI de cualquier otra aplicación, que en nuestro caso nos va a servir de enlace entre la salida del “Conversor Serie a MIDI” que ejecutaremos más adelante y la entrada MIDI de “Pro Tools”. El LoopBe1 una vez instalado quedará siempre ejecutándose en segundo plano dentro de la barra de tareas, a no ser que lo silenciemos (MUTE). En el siguiente enlace nos podemos descargar esta sencilla y práctica aplicación.

Descarga del Puerto MIDI Virtual - LoopBe1 Monitor

Después de tener correctamente conectado todo el HARDWARE a nuestro ARDUINO, el siguiente paso será conectarle al PC a través del USB, para posteriormente cargarle el programa denominado “Bateria_MIDI.ino” que tenemos en descarga directa al final de este POST justo antes del vídeo, como habitualmente venimos haciendo. Doy por hecho de que todos tenemos ya instalado tanto el IDE de ARDUINO como los drivers de la placa, si no es así, os recomiendo pasaros antes por el siguiente POST donde se detalla todo esto. Además, para aprender a subir o cargar correctamente el programa (Sketch) a nuestro ARDUINO tenemos este POST donde también se explica. El siguiente paso será descargar y ejecutar el conversor serie a MIDI como a continuación se indica.

Descarga del conversor -- "Serial MIDI Converter V2D"

Con el conversor en ejecución, la primera prueba que tenemos que hacer para comprobar que nuestro ARDUINO envía correctamente los mensajes MIDI al golpear los PADS o pisar el pedal del bombo es configurarlo como se muestra en la siguiente imagen.

Configuración serie a MIDI básica del conversor

Lo primero que hay que hacer es seleccionar el puerto COM donde tenemos conectado nuestro ARDUINO, después seleccionar la velocidad de comunicación, que en nuestro caso es siempre 57600 bps (BAUDIOS) y por último seleccionar tanto el puerto MIDI de entrada como el de salida como se muestra en la imagen. Todas las opciones de los menús se seleccionan pulsando las letras del teclado del PC que hay entre corchetes antes de cada opción. Si hemos configurado correctamente el conversor, al golpear cualquiera de los PADS o pisar el pedal del bombo sonarán las notas MIDI en piano que tengamos asignadas mediante programación para PAD o el pedal del bombo, además de encenderse los LEDS del PAD que estemos golpeando y por supuesto el cuadrado del Serial RX se tiene que poner de color verde. Esto todavía no tiene mayor relevancia puesto que es solamente para comprobar que todo va bien hasta el momento y que existe una buena comunicación MIDI con el PC, sino fuese así, tendríamos que revisar todo para ver que hemos hecho mal o que se nos ha olvidado hacer. Una vez corroborado todo esto pasamos a configurar definitivamente el conversor de la misma manera que lo acabamos de hacer, para que se comunique con “PRO TOOLS”, como se muestra en la siguiente imagen.

Configuración serie a MIDI del conversor para Pro Tools

Lo que hace el conversor ahora es enviar el MIDI por la salida “LoopBE Internal MIDI” y no directamente al “sintetizador de Microsoft” como hemos hecho en el caso anterior, para posteriormente poder enlazar esa salida MIDI directamente a una entrada MIDI de Pro Tools y a su vez asignar ese MIDI a los platos, tambores y el bombo del “Plugin” EZ Drummer. Siempre que queramos cargar nuevamente un programa en nuestro ARDUINO, tenemos que cerrar el conversor puesto que ocupa la comunicación USB y el IDE quedaría sin posible comunicación con nuestro ARDUINO (Nos tocaría volver a ejecutar y configurar el conversor cada vez que nos comuniquemos con el IDE). Ya nos estamos acercando al resultado final de nuestra batería electrónica, solo nos queda configurar la entrada MIDI en Pro Tools, asignar el “plugin” EZ Drummer a una pista MIDI que crearemos y además crear una pista de audio por si queremos ir grabando nuestros primeros temas y compases. Para ello primero nos descargaremos el siguiente PROYECTO de Proo Tools donde ya he incorporado todo lo necesario para que la batería funcione, aunque todavía tenemos que realizar unos pequeños ajustes dentro del programa.

Descarga del proyecto Arduino Pro Tools 10

Descomprimimos y abrimos la carpeta descargada y ejecutamos el archivo “Arduino.ptx”, de esta manera se nos abrirá ya directamente Pro Tools con todas las pistas necesarias para trabajar. Lo siguiente a realizar, y esto hay que hacerlo siempre que ejecutemos el EZ Drummer, es meter el código de autorización, para ello, vamos a la carpeta EZ Drummer que anteriormente nos descargamos y ejecutamos el “KeyGen.exe”. Después tenemos que copiar el “Computer ID” de la pantalla del EZ Drummer y pegarlo en el KeyGen para posteriormente dar al botón “Generate” y obtener así nuestro código de Autorización que tendremos que ingresar en el EZ Drummer. El programa una vez autorizado tarda unos segundos en cargarse por completo no os pongáis nerviosos. Para finalizar todo esto nos vamos a la pestaña del Pro Tools: “Configuración” à “Periféricos” à “Controladores MIDI” y lo configuramos como se muestra en la siguiente imagen (Tengo el canal 8 seleccionado puesto que es el canal que se utiliza para enviar el MIDI desde Arduino).

Configuración de la entrada MIDI en Pro Tools 10

Ahora solamente nos queda de revisar que la entrada MIDI esté correctamente activado, para ello nos vamos a la pestaña de Pro Tools: “Configuración” à “MIDI” à Dispositivos de entrada … y nos cercioramos de que la casilla “LoopBe Internal MIDI” esté activada. Para finalizar la configuración del SOFTWARE tenemos que revisar la configuración del “Plugin” EZ Drummer para que suene correctamente nuestra batería para ello tenemos que configurar las pistas de la siguiente manera:

Configuración de las pistas en Pro Tools 10

Para que suene la batería solamente nos queda activar el botón “REC” de la pista de “Audio 1”, además para grabar nuestros temas tenemos que activar los botones “REC” y “PLAY” generales de Pro Tools (Arriba a la derecha de la pantalla principal), y comenzar a tocar. A continuación os dejo un video donde podréis seguir paso a paso la configuración de todo lo anteriormente explicado.

Como os vengo repitiendo desde el inicio del POST el programa “Bateria_MIDI.ino” que tenemos que cargar en nuestro ARDUINO simplemente sirve para enviar un mensaje MIDI desde ARDUINO a través del puerto USB hacia el PC, cada vez que golpeamos un PAD o presionamos el pedal del Bombo. Dicho mensaje MIDI está compuesto por el estado de la nota MIDI (ON/OFF), el canal MIDI por el que realizamos la transmisión del mensaje, el tono de la nota MIDI que transmitimos y por último la velocidad con la que se tiene que reproducir dicha nota, para ello utilizamos la función “void MIDI_TX(unsigned char MENSAJE, unsigned char TONO, unsigned char VELOCIDAD)”. Además podemos configurar las siguientes funciones dentro del programa para personalizar nuestra batería electrónica:

· #define canal 7; à Canal MIDI del 0 a 15 (+1 en el "mundo real"). Utilizo el 8 porque es el que utilizo dentro de Pro Tools 10.

· unsigned char Nota[6] = {11,69,50,47,43,58}; à Contiene las notas MIDI que enviamos al presionar los PADS (del 1 al 6). Estas notas MIDI, dependiendo el SOTWARE que estemos utilizando, pueden ser unas u otras (de 0 a 127), aunque en este caso están configuradas para el “Plugin” EZ Drummer dentro de Pro Tools 10 (Charles, caja, TOM 1, TOM 2, TOM de suelo y platillos).

· int Nota_pedal = 36; à Nota MIDI que enviamos cuando pisamos el pedal del Bombo, también configurada para el “Plugin” ES Drummer (Bombo). Mediante el pulsador denominando “pulsador_bombo”, conectado mediante PULL DOWN a la entrada digital 10 de Arduino, podremos cambiar el MODO del pedal del Bombo de “Bombo simple” a “Doble Bombo” al accionarle.

PADS relacionados y notas MIDI dentro de EZ Drummer

· int Sensibilidad_golpeo[6] = {400,400,400,400,400,400}; à Es el valor de la sensibilidad de golpeo de los PADS (valor máximo 1023). A mayor valor menor sensibilidad, es decir, más golpe tendremos que dar en el PAD para que se reproduzca el sonido correspondiente.

· int Respuesta[6] = {70,70,70,70,70,70}; à Es el tiempo mínimo de espera o respuesta entre golpes (en milisegundos). A mayor valor menor respuesta de la batería, es decir, tendremos que esperar más tiempo para poder golpear nuevamente un PAD y que tenga respuesta dentro del “plugin” EZ Drummer.

· int Velocidad_pedal = 120; à Velocidad del pedal entre 0 y 127 (elegir la que más os guste).

· int Tiempo_maximo = 70; à Tiempo mínimo de espera que tiene que transcurrir hasta que se permite pisar una segunda vez el pedal y que suene el Bombo (respuesta del pedal).

Para finalizar os dejo el “Keyboard Layout” de las notas MIDI que relacionan directamente el teclado del editor MIDI de Pro Tools con los respectivos sonidos de batería del “plugin” EZ Drummer.

Keyboard Layout del “plugin” EZ Drummer

Si queréis una mayor información acerca del funcionamiento del programa de ARDUINO os recomiendo revisar los múltiples comentarios añadidos dentro del mismo. Mucha suerte y espero que os funcione correctamente, para cualquier duda no dudéis en contactar conmigo. SALUDOS!!!

Lista de Materiales:

· ARDUINO UNO Rev.3.

· Cable USB tipo A-B.

· 6 Sensores piezoeléctricos.

· 6 Resistencias de 1MΩ.

· 38 LEDS de 3mm (de distintos colores).

· 8 Resistencias de 220Ω.

· 1 Pulsador.

· 2 Interruptores de timbre.

· 2 Trozos de madera (base pedales).

· 4 Tirafondos.

· 3 Resistencias de 10KΩ.

· 6 Tupperware redondos de plástico.

· Plancha de Goma EVA.

· Cola de contacto.

· Soldador de 30W y estaño.

· Protoboard o en su defecto fabricar PCB.

· Cables de conexión.

Código del programa:

Descarga del programa “Bateria_MIDI.ino”

Video:

Comunicación bidireccional entre Arduinos con módulos NRF24L01

noreply@blogger.com (Mariano del Campo) — Mon, 17 Oct 2016 17:11:00 +0000

En este POST realizaremos una comunicación bidireccional inalámbrica o “Duplex” por radiofrecuencia entre dos Arduinos, utilizando módulos NRF24L01, que como ya sabemos del POST anterior estos módulos son TRANCEPTORES, es decir, mediante programación los podemos configurar como emisores o como receptores o configurarlos para que realicen ambas funciones, que es el caso que nos ocupa en este momento. La conexión de los módulos NRF24L01 a los Arduino se hace mediante SPI como siempre, aunque para diferenciar la programación de cada Arduino, los vamos a distinguir llamándolos Arduino “A” y Arduino “B”. La conexión del Hardware va a ser idéntica para los dos Arduinos, es decir, debemos de conectar un pulsador PULL DOWN al pin digital 7 y al mismo tiempo un LED al pin digital 6 de cada Arduino.

Montaje del sistema de comunicación bidireccional RF

A la hora de programar los dos Arduino, al ser una comunicación bidireccional, tenemos que declarar esta vez dos canales (const uint64_t canal[2] = {0xF0F0F0F0E1LL,0xF0F0F0F0D2LL};). Por el canal “0” que es por el que escribe el Arduino “A” tiene que leer el Arduino “B”, y en contraposición, por el canal “1” que es por donde escribe el Arduino “B” tiene que leer el Arduino “A” como se muestra a continuación.

Canales para el sistema bidireccional RF

Una cosa muy importante es darle tiempo a los módulos para que reciban y emitan con un pequeño delay(20), aunque no os preocupéis demasiado porque ya está todo incluido dentro de los programas a descargar. El programa de cada Arduino lo primero que hace es escuchar a través del canal correspondiente para ver si le está llegando información mediante RF, es decir, el valor del estado del pulsador del otro Arduino para que en función de ese valor se encienda o apague el LED que tiene conectado, una vez verificado esto se deja de escuchar por el canal para proceder a enviar el valor del pulsador al otro Arduino, repitiéndose todo esto cíclicamente dentro de la función void loop(). Para más información acerca del funcionamiento de los programas os recomiendo leer los comentarios realizados dentro de la programación.

Lista de Materiales:

· 2 Arduinos UNO Rev.3.

· Cable USB tipo A-B.

· 2 módulos NRF24L01.

· 2 Condensadores electrolíticos de 10µF y más de 5V.

· 2 Pulsadores.

· 2 Resistencias de 10KΩ.

· 2 LED 5mm (de cualquier color).

· 2 Resistencias de 220Ω.

· Fuente de alimentación de 12VDC/3000mA (DC12300).

· Protoboard.

· Cables de conexión.

Código del programa:

• NRF24L01_Bidireccional_A:

Descarga del programa para el Arduino “A”

• NRF24L01_Bidireccional_B:

Descarga del programa para el Arduino “B”

Video:

Comunicación unidireccional entre Arduinos con módulos NRF24L01

noreply@blogger.com (Mariano del Campo) — Thu, 13 Oct 2016 15:55:00 +0000

En este POST realizaremos una comunicación unidireccional inalámbrica por radiofrecuencia entre dos Arduinos, utilizando módulos NRF24L01, cuyo funcionamiento está basado en el chip de Nordic semiconductor NRF24, se pueden alimentan con la salida de 3.3V de nuestro Arduino, tienen muy bajo consumo, se comunican muy rápido y los podemos adquirir por muy poco dinero, que es lo que realmente nos interesa. A continuación os muestro algunas de las principales características de estos módulos:

• Banda ISM de 2.4GHz de operación mundial.

• Hasta una velocidad de datos de 2Mbps.

• Operación a muy baja potencia.

• Voltaje de alimentación de 1.9 a 3.6V.

• ShockBurst™ Mejorado.

• Manejo de paquetes automático.

• Compatible con nRF2401A, 02, E1 y E2.

• Distancia de alcance de 70~100mts en espacio abierto.

Estos módulos son TRANCEPTORES, es decir mediante programación los podemos configurar como emisores o como receptores o configurarlos para que realicen ambas funciones, lo que les convierte en una de las mejores soluciones para realizar comunicaciones inalámbricas, ya sea para domótica, robótica, o lo que se os pueda ocurrir (juguetes, controles remotos, periféricos inalámbricos....). En el mercado existen varios modelos de módulos NRF24L01, de diferentes fabricantes, aunque siempre compatibles entre sí. Todos ellos operan en la banda de 2.4GHz, que es una banda libre de radiofrecuencia, por lo que no requieren de ningún permiso para usarse en ninguna parte del mundo, pero en contra, no tenemos garantía de que no haya alguien más emitiendo en esta banda en las cercanías, lo que puede producir interferencias en nuestra emisiones. Existe un modelo más completo, que aparte del NRF24L01 posee un circuito amplificador de potencia (PA), un circuito amplificador de bajo ruido (LNA) además de una antena SMA que en conjunto le permiten lograr un rango de hasta 1 Km (no os preocupéis demasiado que ya los analizaremos más a fondo en posteriores POST).

Módulo NRF24L01 básico

La distancia o alcance entre módulos NRF24L01 dependerá del modelo que están usando y del lugar en donde están trabajando, si hay muros, ruido, o si están en lugares abiertos. El módulo NRF24L01 con el que vamos a trabajar es el más básico, con un alcance aproximado del orden de una señal WIFI, es decir, por debajo de los 100 metros en espacios abiertos. Aunque estos módulos consumen muy poco cuando estamos trabajando con ellos (Stand By), pueden llegar a absorber en el arranque más de lo que la fuente de 3.3V de Arduino puede proporcionar, lo que impide que arranquen correctamente o que tengan un mal funcionamiento, especialmente en el caso del emisor. Esto lo podemos solucionar fácilmente alimentando los Arduinos mediante una batería de 12VDC/3000mA (fuente de alimentación externa) que administre a nuestros Arduinos una corriente suficiente en todos sus terminales. Además, para eliminar el ruido eléctrico, que en muchos casos hace que nuestros módulos NRF24L01 no funcionen, debemos de conectar un condensador electrolítico de 10µF entre VCC y GND de cada módulo (personalmente me volví loco hasta que conseguí que me funcionaran por este motivo). A continuación os muestro una tabla donde se puede ver la correspondencia de los pines de conexión del NRF24L01 a nuestro Arduino UNO.

Tabla de conexiones del módulo NRF24L01

Para la realización del programa he utilizado las librerías y que podéis descargar en el este enlace . Una vez descargadas las debéis de importar al IDE de Arduino, para después cerrarlo y volverlo a abrir para que se carguen correctamente. Los pines CE y CSN son programables, es decir, les podemos configurar a nuestro antojo (RF24 radio(9,10)), en cambio el resto de los pines deben ser respetados puesto que son los que nuestro Arduino UNO tiene predeterminados para la comunicación SPI. Además debemos de subir a cada Arduino el programa correspondiente teniendo en cuenta la función que tiene que realizar, es decir, si se comporta como Emisor (tiene que tener un pulsador con conexión PULL-DOWN en su pin digital 7) o como Receptor (tiene que tener conectado un LED, a través de una resistencia limitadora de tensión de 220Ω, en su pin digital 7).

Montaje del sistema de comunicación unidireccional RF

Con los programas que podemos descargar en este POST, controlamos el encendido y apagado de un LED con un solo pulsador mediante una conexión por radiofrecuencia (RF) entre dos Arduinos, a través de módulos NRF24L01. Cada vez que presionamos el pulsador conectado al Arduino Emisor, se envía mediante RF el valor de la variable estado_pulsador[0], si es la primera vez que lo presionamos se envía un "1" y si es la segunda vez un "0", repitiéndose el proceso continuamente, para que se encienda o apague un LED conectado al Arduino Receptor, que es el que obtiene a través de RF el valor de la variable estado_pulsador[0]. Cuando la variable estado_pulsador[0] vale "1", se enciende el LED conectado al Arduino (receptor), y si vale "0", el LED se apaga. En el supuesto de que nunca presionemos el pulsador del Arduino Emisor, no se enviará ningún valor mediante RF y como consecuencia el LED conectado al Arduino Receptor permanecerá apagado. Para una mayor información os recomiendo echar un vistazo a los comentarios realizados dentro de los programas.

Lista de Materiales:

· 2 Arduinos UNO Rev.3.

· Cable USB tipo A-B.

· 2 módulos NRF24L01.

· 2 Condensadores electrolíticos de 10µF y más de 5V.

· 1 Pulsador.

· Resistencia de 10KΩ.

· LED 5mm (de cualquier color).

· Resistencia de 220Ω.

· Fuente de alimentación de 12VDC/3000mA (DC12300).

· Protoboard.

· Cables de conexión.

Código del programa:

• Emisor NRF24L01:

Descarga del programa para el Emisor

• Receptor NRF24L01 :

Descarga del programa para el Receptor

Video:

Generar frío con una Célula Peltier cerámica TEC1-12706

noreply@blogger.com (Mariano del Campo) — Thu, 06 Oct 2016 15:40:00 +0000

Hoy continuamos con nuestro aprendizaje dentro del mundo de la electrónica y por supuesto siempre con ARDUINO UNO, generando frío a partir de una célula Peltier. Está célula será controlada mediante dos pulsadores, uno para su encendido/apagado en el modo manual, donde la Célula Peltier se irá enfriando paulatinamente hasta llegar a la temperatura mínima límite (depende de la potencia con la que la alimentemos la célula), y el otro pulsador para entrar en el modo PID en el que la Célula Peltier trabajará de manera automática para mantener la temperatura de su cara fría entre unos rangos predefinidos (entre 16 y 18°C aproximadamente). La medida de dicha temperatura la realizaremos mediante el sensor de temperatura DS18B20, que montaremos sobre la cara fría de la Célula, además todo el proceso podrá ser visualizado a través de un display LCD 2004. Sin más preámbulos comenzaré analizando todos los componentes de los que necesitamos para realizar este curioso proyecto, además de mostraros la manera de enlazarlos y programarlos a través de nuestro ARDUINO.

Célula Peltier cerámica TEC1-12706

Una Célula Peltier o enfriador termoeléctrico (TEC) es un dispositivo capaz de generan una diferencia de temperatura entre sus caras cuando circula una corriente a través de él, es decir, una de sus caras se enfría (absorbe calor), mientras que la otra se calienta (emite calor). El papel de cada cara depende del sentido de la corriente, de hecho, es posible invertir el flujo de calor invirtiendo el sentido de la corriente, aunque nosotros la vamos a alimentar directamente sin invertir sus polos, es decir, polo positivo de la célula al positivo de la fuente de alimentación y el negativo al negativo. En consecuencia, puede ser utilizada para enfriar, por debajo de la temperatura ambiente, a objetos que se encuentren en contacto con su cara fría, siendo ideal en controles de temperatura como el que se desarrolla en este POST. Como dato deciros que internamente está formada por múltiples celdas de materiales N y P ubicadas entre sus dos caras cerámicas. Habitualmente se emplea Telurio y Bismuto como semiconductores y óxido de aluminio para las placas cerámicas, aunque no voy a entrar a analizar su comportamiento termodinámico en profundidad el día de hoy.

Funcionamiento de la célula Peltier

Esta célula Peltier, para su correcto funcionamiento debe ser alimentada mediante una fuente de 12VDC y 8,5A (100W), puesto que tiene que generar la suficiente potencia para alimentar los 60W aproximados que consume la célula, además de poder alimentar el ventilador del disipador que también trabaja a 12V. Dado que la célula consume una cantidad considerable de corriente hay que tener en cuenta que la fuente de alimentación tenga la corriente suficiente, si no, no va a funcionar la célula con su máxima eficiencia. Como Arduino únicamente nos suministra salidas de 5VDC y unos pocos miliamperios, tendremos que utilizar un módulo relé de 5VDC junto con Arduino para poder controlar la potencia de la fuente de alimentación y de esta manera controlar el comportamiento de la célula Peltier (ON/OFF).

Célula Peltier con disipador, ventilador y sonda de temperatura

El problema nos surge ahora, es decir, para hacer funcionar una célula Peltier debemos dar salida al calor generado en la cara caliente, para lo cual deberemos de instalar un sistema de disipación. Cómo mínimo, debemos ubicar un disipador con ventilador en el lado caliente (el lado de la serigrafía TEC1-12706, es el lado frío). No hagáis funcionar una célula Peltier sin un sistema de disipación, puesto que elevará su temperatura rápidamente y se fundirá en pocos segundos, además las temperaturas alcanzadas son suficientemente altas para ser peligrosas al contacto. Para que exista una transferencia de calor correcta entre la célula y el disipador, es muy conveniente utilizar pasta térmica entre ambos componentes. Las caras de la celda están fabricadas en un material cerámico especial, que es un buen aislante eléctrico y buen conductor del calor, pero que es relativamente frágil mecánicamente, por lo que no debe ser sometido a golpes ni grandes esfuerzos. A continuación se destacan algunas de las características más relevantes de esta célula Peltier.

Características célula Peltier TEC1-12706

Las bajas temperaturas alcanzadas en la cara fría pueden dar lugar a la condensación de agua. Esta agua puede dañar los elementos que deseamos refrigerar, sobre todo en el caso de componentes electrónicos, por eso he optado por instalar el sensor de temperatura DS18B20 puesto que resiste eficientemente la humedad y la corrosión. El sensor de temperatura DS18B20 es un dispositivo que se comunica de forma digital con nuestro ARDUINO. Cuenta con tres terminales, los dos de alimentación y el pin “DATA”. Con Arduino podemos “leer” la temperatura que registra este sensor mediante la comunicación OneWire, que básicamente se trata de un protocolo especial que permite enviar y recibir datos utilizando un solo cable. Para una conexión correcta de este sensor, debemos de unir sus pines VCC y GND (negro y rojo) y conectar el pin DATA mediante una resistencia de 4,7KΩ a +5VDC de ARDUINO (resistencia PULL-UP), y a su vez este pin DATA debe de ir conectado al pin digital de ARDUINO por el que leemos la temperatura, que en nuestro caso es el pin digital 6 (“PIN_sensor”), para procesar los datos posteriormente mediante programación.

Sensor de temperatura DS18B20

Es importante revisar exhaustivamente las conexiones para que el sensor pueda realizar una lectura de la temperatura de manera correcta. El código requiere de la utilización de dos librerías (DallasTemperature.h y OneWire.h), que deben ser descargadas e instaladas dentro del IDE antes de cargar el código a nuestro ARDUINO. A continuación os muestro las principales características de este sensor de temperatura.

Características sensor de temperatura DS18B20

El display LCD 2004 de 4 filas y 20 caracteres por fila, además de alimentarlo correctamente (+5V y GND de Arduino) lo conectamos a nuestro Arduino mediante protocolo I²C (pines SDA y SCL), para poder visualizar el estado del sistema en todo momento (temperatura y modos de funcionamiento). Los dos pulsadores se han de conectar a través de una resistencia de 10KΩ a GND de Arduino (resistencia PULL-DOWN), y a su vez un pulsador lo conectaremos al pin digital 8 (“Pulsador_Peltier”) de ARDUINO para el modo normal de funcionamiento ON/OFF de la célula Peltier y el otro pulsador al pin digital 7 (“Pulsador_PID”) para el modo de funcionamiento PID, donde la célula trabaja automáticamente entre un rango de temperaturas. Por último decir que el pin de control del módulo relé de 5VDC debe de ir conectado al pin digital 9 (“RELE”) de nuestro ARDUINO. Para una mayor información os recomiendo consultar el esquema de conexión y los comentarios realizados dentro del programa, que debemos de subir a nuestro ARDUINO para el correcto funcionamiento del sistema.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Módulo LCM 2004 I2C V1.

· Display 20x4 LCD 2004.

· Célula Peltier cerámica TEC1-12706 (12VDC – 60W).

· Fuente de alimentación de 12VDC – 8,5A (modelo CD-100W).

· Disipador de CPU con ventilador de 12VDC.

· Pasta térmica (HY410).

· Sensor de temperatura DS18B20 (sumergible).

· Módulo relé de 5VDC (SRD-05VDC-SL-C).

· 2 Pulsadores.

· 2 Resistencias de 10KΩ.

· 1 Resistencia de 4,7KΩ.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Control del motor a pasos unipolar 28BYJ-48 mediante el driver ULN2003

noreply@blogger.com (Mariano del Campo) — Mon, 26 Sep 2016 10:48:00 +0000

En este POST os voy a mostrar cómo controlar tanto el sentido y velocidad de giro como la posición del eje de un motor a pasos (Stepper) unipolar 28BYJ-48, mediante la utilización del módulo driver ULN2003. El uso de este pequeño motor es muy habitual cuando se requiera un posicionamiento con precisión, como puede ser en pequeñas aplicaciones de robótica, en máquinas CNC o en impresoras 3D.

Motor a pasos unipolar 28BYJ-48

Aunque no es ni demasiado potente ni rápido, tiene un buen comportamiento junto con Arduino, además de ser bastante económico y fácil de encontrar en cualquier tienda online de electrónica. Las características más importantes de este motor a pasos se detallan a continuación.

Características del motor a pasos unipolar 28BYJ-48

Nosotros vamos a conectar el motor a pasos en su modo “Half Steps”, es decir, en un principio necesitaríamos 8 medios pasos o impulsos para completar un giro completo del eje del motor, pero teniendo en cuenta que el motor está dotado de una reductora de 1/64, finalmente necesitamos dar 8 * 64 = 512 pulsos para completar un giro completo en este modo de conexión (256 pulsos para media vuelta por ejemplo), teniendo en cuenta que el movimiento es más suave y lento que con el modo “Full Steps” que únicamente utiliza 4 pasos, y el consumo y el par es intermedio. Para ello, y teniendo en cuenta que el motor está dotado únicamente de 4 bobinas, para que el motor gire por ejemplo en el sentido de las agujas del reloj (horario) tendríamos que ir excitando las bobinas según la secuencia 1, 2, 3… 7 y 8, de ahí las 8 señales necesarias para el correcto funcionamiento del motor (ver siguiente imagen). Si por el contrario queremos que el eje del motor gire en sentido contrario (antihorario), debemos de invertir el orden de la secuencia (8, 7, 6… 2, 1).

Secuencia de excitación de las bobinas

Como se ha mencionado anteriormente vamos a utilizar el módulo driver ULN2003 que conectaremos a nuestro Arduino, para poder excitar las bobinas en la secuencia correspondiente mediante programación. Como cabía esperar este módulo basa su funcionamiento en el chip ULN2003, el cual permite amplificar las señales PWM y digitales de nuestro Arduino a voltajes y corrientes mucho mayores, es decir, es capaz de manejar hasta 25V y 0.5A en cada una de sus salidas. Internamente está formado por siete pares de transistores NPN Darlington de uso general para controlar relés, motores, lámparas LED, y otras aplicaciones de corriente de alta tensión, incluyendo diodos de fijación de cátodo común para cada par Darlington NPN, lo que hace que este chip sea muy útil para la conmutación.

Modulo driver ULN2003

Además este módulo está dotado de 4 LEDS que indican qué bobina está activa en cada momento. La entrada de alimentación del módulo permite un voltaje comprendido entre 5 y 12VDC, siempre que el JUMPER permanezca en “ON”. Es recomendable el uso de una batería externa para la alimentación del módulo (en cuyo caso debemos unir la masa de la batería con la de nuestro Arduino para un correcto funcionamiento), ya que el motor a pasos puede consumir más corriente de la que nuestro Arduino es capaz de suministrar y de este manera dañarlo, aunque yo lo he conectado directamente a los +5V de Arduino y funciona sin problemas. La conexión entre el módulo y el motor a pasos es bastante intuitiva ya que tiene un conector con ranuras para guiar el acople entre los dos dispositivos (5 cables). También deciros que los pines IN1, IN2, IN3 e IN4 pertenecen a las entradas de control del módulo, y son las que irán conectadas a las salidas digitales de Arduino (pines digitales del 8 al 11 empezando por el IN1 con el pin digital 8).

Como ya os anticipaba al principio de este POST, con el programa que se muestra a continuación, seremos capaces de controlar tanto el sentido y velocidad de giro como la posición del eje del motor a pasos unipolar 28BYJ-48 a través del módulo driver ULN2003, siempre que previamente hayamos hechos las conexiones oportunas de las que el conjunto requiere y hayamos cargado el programa correctamente en nuestro Arduino. El programa consta de 5 estados de movimiento posibles que comandaremos a través de un interruptor táctil capacitivo TTP224 de 4 Vías, cuyas salidas tenemos conectadas a las entradas digitales 4, 5, 6 y 7 de nuestro Arduino (salidas OUT4, OUT3, OUT2 y OUT1 respectivamente). Os dejo aquí el enlace donde podéis descargar la imagen para cada uno de los botones.

Interruptor táctil capacitivo TTP224 de 4 Vías

Para que podáis entender mejor lo que se logra realizar mediante este programa, os muestro una tabla resumen de dichos movimientos y el botón que tendremos que pulsar del interruptor táctil capacitivo TTP224, cuyo voltaje de alimentación oscila entre 2,4 y 5,5VDC, para que nuestro Arduino actúe en consecuencia.

Tabla de movimientos del eje del motor a pasos 28BYJ-48

En número de vueltas se controla modificando el número de pasos en la variable “pasos”, siendo 512 pasos el equivalente a una vuelta completa. La velocidad del motor se controla aumentando o no el retardo entre cada secuencia completa, modificando la variable “velocidad_motor” (como mínimo 900 ms para velocidad máxima), si aumentamos su valor, por ejemplo 4000 ms, la velocidad disminuye. El sentido de giro se controla utilizando las funciones “horario()” y “antihorario()”. Por último deciros que a través del monitor serie del IDE de Arduino se irán mostrando los oportunos mensajes sobre del estado del eje del motor en cada momento. Para mayor información os recomiendo consultar los comentarios realizados en el programa.

Monitor serie del IDE de Arduino

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Motor a pasos unipolar 28BYJ-48.

· Módulo driver ULN2003.

· Interruptor táctil capacitivo TTP224 de 4 Vías.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Conectando dos LCD 1602 independientes mediante comunicación I²C

noreply@blogger.com (Mariano del Campo) — Tue, 13 Sep 2016 11:18:00 +0000

Después de estar un tiempo sin dedicarme al BLOG, a partir de hoy retomo la publicación de nuevos POST de manera más o menos continuada como hasta ahora he estado haciendo. Hoy simplemente os voy a mostrar como conectar dos displays LCD 1602 mediante comunicación I²C, sin que su comunicación con nuestro Arduino se cruce, es decir, cada LCD 1602 trabajará de manera independiente. Aunque en este POST nosotros vamos a trabajar con dos LCD 1602, podríamos conectar teóricamente hasta “127” LCD 1602 a nuestro Arduino mediante comunicación I²C, aunque de momento y gracias al módulo LCM 1602 I2C (en sus dos versiones V1 y V2) es posible conectar simultáneamente un máximo de “16”, teniendo en cuenta que sería necesario alimentarlos a +5V externamente y no desde Arduino, puesto que cada versión del módulo LCM 1602 I2C nos ofrece la configuración de ocho direcciones diferentes mediante sus pines A2, A1 y A0 (soldándolos o no a GND), como se muestra en la siguiente imagen.

Tabla de direcciones de los módulos LCM 1602 I²C

Para una mayor información acerca de la conexión y configuración de la dirección I²C en cada uno de los LCD 1602 es importante que analicéis el siguiente POST , teniendo en cuenta que lo más importante para que nos funcionen correctamente ambos LCD 1602 es que cada uno de los módulos LCM 1602 I2C tenga asignada una dirección I²C diferente, para que a través de nuestro Arduino podamos acceder a ella de manera independiente mediante programación.

El programa que tenemos que cargar en nuestro Arduino simplemente realizará un parpadeo alterno inicial de los LCD 1602, para que posteriormente muestren unas líneas de texto diferentes para cada LCD 1602 y finalmente se realice un barrido vertical en bucle continuo de un conjunto de asteriscos a través de ellos, sin que se mezcle la comunicación en ningún momento (para una mayor información debemos de analizar los comentarios del programa).

Este tipo de comunicación en los LCD 1602 es muy interesante cuando conectamos varios sensores a nuestro Arduino y queremos visualizar los resultados de manera independiente, es decir, si por ejemplo tenemos conectados un sensor de temperatura y otro de presión a nuestro Arduino, podremos visualizar un sólo parámetro de manera individual en cada uno de los LCD 1602, para poder acceder a ellos desde diferentes ubicaciones o salas (un LCD 1602 mostraría la temperatura y el otro la presión).

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Dos módulos LCM 1602 I2C (Versiones V1 y V2).

· Dos displays 16x2 LCD 1602.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Robot Miniskybot 2.0 controlado a través de Bluetooth

noreply@blogger.com (Mariano del Campo) — Wed, 06 Jul 2016 16:08:00 +0000

Hoy os voy a enseñar a controlar, a través de Bluetooth, el “Robot Miniskybot 2.0” que construimos en un POST anterior. Para ello utilizaremos una aplicación, para Smartphones con Sistema Operativo Android, llamada ”Wise HC-06 Carrinho Bluetooth”, mediante la cual, enviaremos una cadena de caracteres única a través de Bluetooth, cada vez que pulsemos cualquiera de las flechas de control de las que dispone la aplicación, a un módulo HC-06 que tendremos conectado a nuestro Arduino, para que este decodifique las cadenas enviando las ordenes de movimiento a los dos servos de rotación continua del “Robot Miniskybot 2.0", que son los encargados de generar el movimiento.

Aplicación para Android “Wise HC-06 Carrinho Bluetooth”

La aplicación para Android “Wise HC-06 Carrinho Bluetooth” la podemos obtener directamente desde la “Play Store” de nuestro Smartphone Android o instalarla a través de nuestro PC en este enlace.

Como de momento no se ha trabajado nunca con dispositivos Bluetooth en este BLOG, nos vamos a parar un poco para poder comprender este tipo de comunicación y en concreto describir el funcionamiento del módulo Bluetooth HC-06, que tan comúnmente se va a utilizar junto con nuestro Arduino, puesto que es inevitable utilizar un módulo Bluetooth HC-06 o HC-05 como puerta de enlace entre los dispositivos Bluetooth, tales como Smartphones o PC´s, y nuestro Arduino, ya que por sí solo no es capaz de comunicarse con este tipo de tecnología.

· Facilitar las comunicaciones entre equipos móviles.

· Eliminar los cables y conectores entre éstos.

· Ofrecer la posibilidad de crear pequeñas redes inalámbricas.

· Facilitar la sincronización de datos entre equipos personales.

Logotipo del dispositivo Bluetooth

El módulo de Bluetooth HC-06 se trata de un dispositivo relativamente económico y que habitualmente se vende en un formato que permite insertarlo en un protoboard y cablearlo directamente a nuestro Arduino, incluso sin realizar soldaduras. Algunas de las características más importantes de este dispositivo se describen a continuación:

· Compatible con el protocolo Bluetooth V2.0.

· Voltaje de alimentación: 3.3VDC – 6VDC.

· Voltaje de operación: 3.3VDC.

· Baud rate ajustable: 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200.

· Trabaja exclusivamente en modo esclavo, es decir, solo recibe datos.

· Corriente de operación: < 40 mA

· Corriente modo sleep: < 1mA

Módulo Bluetooth HC-06

Podemos cambiar las configuraciones de velocidad de transmisión de datos, el código de emparejamiento, el nombre, etc. mediante un protocolo denominado comandos AT. Para poder hacerlo es necesario que el HC-06 no este emparejado ni siendo usado por ningún dispositivo aunque no es el propósito de este POST, sino que simplemente utilizaremos los valores por defecto que el módulo trae programados, aunque es posible que hayan sido manipulados y tengamos que recurrir a los comandos AT.

· Nombre por defeco: “linvor” o “HC-06”.

· Código de emparejamiento por defecto: 1234.

· La velocidad por defecto (BAUD RATE): 9600.

Para conectar el módulo Bluetooth HC-06 con la aplicación de Android, lo primero que tendremos que hacer es encender el Bluetooth de nuestro Smartphone y cerciorarnos de que el módulo Bluetooth HC-06 esté correctamente alimentado (+5V y GND) y conectado a nuestro Arduino de la siguiente manera:

· Pin TX del módulo Bluetooth HC-06 à Pin digital 10 de Arduino.

· Pin RX del módulo Bluetooth HC-06 à Pin digital 11 de Arduino.

Posteriormente tendremos que vincular el módulo Bluetooth HC-06 con nuestro Smartphone como si de cualquier otro dispositivo Bluetooth se tratara, es decir, una vez encontrado el módulo Bluetooth HC-06 (con nombre “linvor” o “HC-06” si no lo hemos modificado mediante comandos AT), tendremos que ingresar el código de emparejamiento (1234 si no la hemos modificado mediante comandos AT). Por último, abriremos la aplicación y pulsaremos sobre el icono del Bluetooth para que nos muestre la lista de dispositivos vinculados a nuestro Smartphone, donde tenemos que seleccionar la conexión con nombre “HC-06” para conectarnos al módulo Bluetooth HC-06. Solo tendremos que fijarnos que si hemos realizado la conexión Bluetooth correctamente, el LED de conexión del módulo Bluetooth HC-06 dejará de parpadear para finalmente quedarse encendido todo el tiempo y de esta manera sabremos que todo está ya listo para que comience a moverse el “Robot Miniskybot 2.0” en distintas direcciones, cada vez que pulsemos sobre las diferentes flechas de la aplicación.

Para la programación del robot he tenido en cuenta los cinco estados siguientes:

• Avance: Recibe la cadena “F1S0“ à Flecha arriba de la aplicación.

• Retroceso: Recibe la cadena “T1S0“ à Flecha abajo de la aplicación (si el robot está parado).

• Paro: Recibe la cadena “T1S0“ à Flecha abajo de la aplicación (si el robot está moviéndose).

• Derecha: Recibe la cadena “D1S0“ à Flecha derecha de la aplicación.

• Izquierda: Recibe la cadena “E1S0“ à Flecha izquierda de la aplicación.

Al pulsar cada una de las flechas de la aplicación, el robot se moverá en una dirección concreta, a excepción de la flecha hacia abajo, puesto que si el robot está en movimiento, al pulsarla el robot se para, y si el robot está parado, al pulsarla se moverá marcha atrás (retroceso). El tratamiento de las cadenas de caracteres que recibe nuestro Arduino a través de Bluetooth se realiza dentro del programa mediante sentencias “if”, además de incluir múltiples comentarios que nos aclaran el funcionamiento de todo el sistema.

Por último y antes de que se me olvide, tengo que darle las gracias a “Adriano Moutinho” por haber creado una aplicación tan simple y funcional, y a vosotros deciros que es muy importante dejar votos positivos en las aplicaciones gratuitas que os descarguéis, para que los desarrolladores obtengan algún tipo de beneficio con su trabajo, aunque solo sea el del reconocimiento del mérito personal.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Módulo Bluetooth HC-06 (Esclavo).

· 2 Servos de rotación continua (SM-S4306R).

· Portapilas 6xAAA con conector Jack macho de 2,1mm.

· 6 pilas recargables AAA de 1000mAh con cargador.

· Robot Miniskybot 2.0:

o Chasis y dos ruedas impresos en plástico ABS.

o 4 tornillos de M3x10mm y 4 tuercas M3.

o Canica de 16mm de diámetro.

o 2 Juntas tóricas de 50mm de diámetro y 3 mm de grosor.

· Gomas elásticas para la sujeción de los elementos.

· Smartphone con S.O Android.

· Aplicación “Wise HC-06 Carrinho Bluetooth” (Play Store).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Alarma de seguridad láser con mini altavoz y LED incorporados

noreply@blogger.com (Mariano del Campo) — Wed, 29 Jun 2016 15:46:00 +0000

En este POST vamos a construir una alarma muy funcional y fácil de programar, ya que consta de unos elementos muy baratos y simples de conseguir en cualquier tienda de electrónica, bien sea la de tu ciudad o cualquiera de las tiendas online existente en la WEB, como pueden ser unos LED, resistencias, un pequeño altavoz de 8Ω y lo más importante de todo un módulo emisor láser y otro receptor (fotoreceptor).

El módulo emisor láser ya le hemos utilizado en otro POST, por lo que simplemente decir, que una vez que lo alimentamos con +5VDC y GND de Arduino, a través de sus pines “+” y “-“ respectivamente, necesitamos conectar su pin “S” a una de las salidas digitales de Arduino (pin digital 6), para que al cargar y ejecutar el programa en nuestro Arduino, el módulo emisor láser permanezca encendido de manera continua. Antes de continuar y por experiencia propia os tengo que explicar que muchos módulos láser, si los habéis adquirido en páginas chinas, suelen tener cambiados los pines “-“ y “S”, por lo que tendremos que invertir estas dos conexiones para conseguir que nos funcione. Como precaución importantísima antes de utilizar un módulo emisor láser, os advierto de que nunca debemos apuntar directamente a los ojos de personas ni animales, puesto que este láser aunque es de baja potencia (5mW), es capaz de dañar gravemente la visión, incluso a largas distancias.

Módulos receptor y emisor láser

El módulo receptor láser, es simplemente un pequeño PCB basado en el funcionamiento de un fotoreceptor, el cuál manda una señal al detectar la luz del láser, que también tendremos que alimentar con +5VDC y GND de Arduino, a través de los pines VCC y GND respectivamente, para que en ausencia de luz en el receptor, es decir, cuando algo se interponga en la trayectoria del rayo láser, su pin “OUT” (salida), que tendremos conectado a una entrada digital de Arduino (pin digital 7), estará a nivel BAJO (LOW), y por el contrario, cuando incida el rayo láser en el receptor, su salida estará a nivel ALTO (HIGH). Para que este sistema funcione de esta manera, deberemos de alinear correctamente el rayo del emisor láser con la ventana de detección del fotoreceptor, además de proteger el receptor láser mediante una pequeña caja, para que solo sea estimulado mediante el rayo láser a través de un pequeño orificio que tendremos que realizar en la caja y de esta manera evitar las interferencias luminosas provenientes de la luz ambiente del lugar donde instalemos nuestra alarma de seguridad. A continuación os muestro un modelo de estructura que se puede crear a partir de cartón rígido o en madera para que tanto el emisor como el receptor láser queden correctamente alineados y resguardados.

Estructura para la alarma de seguridad láser

Conociendo ya el funcionamiento tanto del receptor como del emisor láser, solamente tendremos que realizar la programación y conectar tanto los LED como el altavoz para que estos se accionen cuando el rayo láser no esté enfocando al receptor, es decir, cuando exista una presencia entre el receptor y el emisor. Para ello conectaremos los terminales positivos de los LED (uno de color naranja y el otro azul), a dos salidas digitales de Arduino (pines digitales 3 y 4 respectivamente), conectando los terminales negativos de los LED a GND de Arduino a través de resistencias de 220Ω para limitar la corriente de salida y no quemarles. Aunque yo he realizado un pequeño PCB para la conexión de los LED y las resistencias, no es necesario puesto que podemos conectarlos directamente en una Protoboard. Por otro lado el terminal positivo del altavoz lo conectaremos a otra salida digital (pin digital 5) y el terminal negativo como siempre a GND. Para mayor información sobre la instalación y funcionamiento de esta alarma de seguridad láser, deberemos repasar los comentarios realizados en el programa que tenemos listo para descargar en este POST y así poder subirlo a nuestro Arduino a través del mismo IDE que el fabricante nos ofrece como herramienta de programación de la tarjeta.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Módulo emisor láser.

· Módulo receptor láser.

· 2 LED de 5mm (Azul y naranja).

· 2 Resistencias de 220Ω.

· Mini-altavoz de 8Ω (ABS-210-RC).

· Cartón (para la estructura).

· Silicona o pegamento de contacto.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Panel luminoso de Matrices LED 8x8 con driver MAX7219

noreply@blogger.com (Mariano del Campo) — Wed, 22 Jun 2016 17:00:00 +0000

En este tutorial aprenderemos a controlar las matrices LED de 8×8 con Arduino, en concreto vamos a usar los módulos que llevan el driver MAX7219, y para controlarlos utilizaremos la librería “MaxMatrix.h”, que nos facilitarán enormemente el trabajo. Lo que haremos en cuestión, será mostrar un mensaje en forma de texto que se va a desplazar de derecha a izquierda (Scroll horizontal) a través de las 4 matrices LED 8x8 que conectaremos en cascada, repitiéndose constantemente.

La Matriz LED de 8×8, está compuesta por 64 LED de 3mm, en color rojo. Internamente los LED, están montados con cátodo común dentro de un encapsulado sólido de fibra de vidrio para protegerles. Algunas de las principales características de las matrices LED 8x8 se describen a continuación:

· Voltaje de Trabajo: 4.7 -5.3 V

· Tensión típica: 5 V

· Consumo de corriente: 320mA

· Corriente de trabajo máxima: 2A

· Temperatura: 0 -50 °C

· Temperatura de trabajo: 25

El driver MAX7219 (de Maxim) que contiene cada módulo, sirven para implementar una interfaz SPI (Serial Peripheral Interface, que es básicamente un bus de comunicación a nivel de circuitos integrados en el que la transmisión de datos se realiza en serie, es decir un bit después de otro) en cada uno de ellos, para que se puedan comunicar con nuestro Arduino exclusivamente por medio de 3 pines digitales de salida (DIN, CS y CLK), además de dos pines para la alimentación (+5V) y la masa (GND). A continuación se detallan sus principales características:

· Entrada y salida en serie, para necesitar menos pines.

· Controla displays de 7 segmentos de hasta 8 dígitos, Bar graph displays (Barras de LED) y Matrices de 8×8 o de hasta 64 LED individuales.

· Solo requiere una resistencia externa para los 64 LED.

· Incluye decodificador BCD (No hay necesidad de dibujar matrices de caracteres, las lleva incluidas. Mayúsculas, minúsculas y hasta números y signos).

· Se encarga del multiplexado de los caracteres y dígitos.

· Incluye memoria de los caracteres.

· Es compatible con interfaz SPI y QSPI.

Para conectar en cascada las 4 matrices LED 8x8 con driver MAX7219 (aunque por este método podríamos conectar hasta 8), que nos van a hacer falta para desarrollar este proyecto, es imprescindible conectar a nuestro Arduino la matriz LED 8x8 que se encuentra más a la derecha de todas, teniendo en cuenta que el mensaje de texto se va a mover hacia la izquierda. A continuación se muestra la relación de los pines a conectar:

Correspondencia de los pines entre nuestro Arduino y el driver MAX7219

Posteriormente necesitamos conectar las salidas del módulo situado más a la derecha (CLK, CS, DOUT, GND y VCC) a las entradas del siguiente (CLK, CS, DIN, GND y VCC) y así sucesivamente con los restantes módulos, hasta llegar al que esté situado más a la izquierda, el cual no necesita que sus salidas estén conectadas. Como en las matrices LED 8x8 con driver MAX7219 viene rotulado en la parte inferior la función de cada pin y cuales son de salida y cuáles de entrada, solo necesitaremos un poco de paciencia para poder realizar correctamente las conexiones. Un pequeño detalle a tener en cuenta es que el pin “DIN” es el correspondiente a la entrada de datos y el pin “DOUT” es el correspondiente a la salida de datos, con lo que tenemos una referencia a mayores para poder distinguir que grupo de pines son de entrada y cuáles de salida.

Conexión de las 4 matrices LED 8x8 con driver MAX7219

Cabe aclarar que debido a la existencia de infinidad de fabricantes de este tipo de módulos, nos podemos encontrar con el problema de que al adquirirlos, nos vengan sin soldar o que no tengan terminales de conexión en sus pines de E/S, por lo que tendremos que ingeniárnoslas para realizar las conexiones entre los módulos mediante pequeños cablecitos, un soldador, estaño y bastante paciencia, ya que precisamente es lo que a mí me ocurrió al adquirirlos a muy bajo precio en “China”, aunque viendo los resultados obtenidos, merece la pena ahorrarse un dinero aunque tengamos que desempolvar nuestras herramientas de soldadura.

Diferentes versiones de matriz LED 8x8 con driver MAX7219

Por último os comento que dentro de la programación podremos cambiar tanto el mensaje o mensajes de texto que queráis mostrar, como el brillo de los LEDS (si alimentamos el panel luminoso a través de nuestro Arduino es recomendable que esté en el nivel 1 para evitar fallos al subir el programa), el número de módulos conectados en cascada (máximo 8) o incluso la velocidad con la que se va a desplazar el texto, aunque para poder realizar todo esto es necesario recurrir al código del programa donde deberemos modificar las líneas de código necesarias, aunque no os preocupéis porque el código está comentado al detalle. Es muy importante subir el programa a nuestro Arduino sin tener alimentado el panel luminoso (pines +5V y GND), puesto que teniendo en cuenta que cada matriz LED 8x8 tiene un consumo aproximado de 350mA tendríamos un consumo total de unos 1400mA, un consumo excesivamente elevado para la salida USB de nuestro PC, lo que hará que al intentar subir el programa a nuestro Arduino, el puerto serie se nos desconecte dándonos un error en el IDE de Arduino. Después de subir el programa conectaremos nuevamente la alimentación del panel luminoso y procederemos a resetear nuestro Arduino para que los mensajes comiencen a deslizarse de derecha a izquierda a través de las matrices LED 8x8. (Es muy recomendable alimentar el panel luminoso con una fuente de alimentación de 5VDC para que esto no suceda).

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· 4 Matrices LED 8x8 con driver MAX7219.

· Soldador de 30W y estaño (en el caso de que sea necesario).

· Fuente de alimentación de 5VDC/3000mA (opcional).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Monedero electrónico con display LCD 1602

noreply@blogger.com (Mariano del Campo) — Wed, 08 Jun 2016 16:25:00 +0000

Hoy os traigo un sencillísimo monedero electrónico, que dotaremos de un display LCD 1602 con comunicación I2C, para que a través de este, Arduino nos muestre el número de créditos o monedas que vamos insertando a través de la ranura que el monedero electrónico tiene. Tomaremos como moneda de referencia la de 50 céntimos de Euro, aunque podría ser cualquier otra, por lo que si insertamos cualquier moneda diferente, esta será rechazada por el monedero electrónico y por lo tanto no se tendrá en cuenta un nuevo crédito. Además este pequeño sistema está dotado de un pulsador, mediante el cual, seremos capaces de bajar un crédito del contador de créditos que muestra el display LCD 1602, cada vez que lo pulsemos.

Monedero Electrónico

Una de las grandes ventajas de este monedero electrónico, es que rechaza las monedas falsas, monedas dobladas y arandelas, además de tener gran precisión cuando tiene que diferenciar dos monedas de tamaño muy similar pero de diferente denominación. Requiere de una fuente de alimentación regulada de 12VDC para su funcionamiento, es decir, para que su circuitería interna y el solenoide estén correctamente alimentados (Pines +12VDC y GND). El monedero nos entregará un pulso eléctrico de unos 2-3VDC a través de su pin “COIN”, cada vez que insertemos una moneda correcta en su interior, y será el encargado de habilitar la interrupción INT0 (pin digital 2) en nuestro Arduino. Este monedero también está dotado de un pin de salida denominado “COUNTER” que se encarga de enviar un pulso, que pueda ser leído por un contador electrónico externo, cada vez que insertamos la moneda correcta, aunque en este POST no lo vamos a utilizar. Mediante el interruptor NC/NO podemos seleccionar en qué niveles lógicos va a trabajar el pulso de salida del monedero, es decir, o estado normalmente abierto (NO) o normalmente cerrado (NC). Si seleccionamos NO el monedero cuando está en espera se mantiene todo el tiempo entregando un voltaje en su salida (ALTO). Al momento que recibe una moneda correcta, el monedero corta el voltaje momentáneamente (BAJO) y vuelve a su estado NO en el que entrega voltaje (ALTO). De lo contrario si seleccionamos NC el monedero cuando está en espera, se encuentra en estado cerrado (BAJO) y no entrega ningún voltaje o pulso. Al momento de recibir una moneda correcta, entrega un pulso (ALTO) y luego vuelve a su estado NC, en el que no entrega ningún voltaje (BAJO).

Alimentación, salidas e interruptor de niveles lógicos

Este monedero puede ser configurado instantáneamente para aceptar prácticamente cualquier denominación de moneda al tiempo que rechaza todas los demás. La configuración para la aceptación de las monedas se establece mediante la inserción de una denominación de la moneda en un espacio llamado “CUNA”, que es donde yo he insertado la moneda de 50 céntimos de Euro.

Cuna del monedero electrónico

También, mediante otro interruptor, podemos seleccionar la velocidad correcta de aceptación de la moneda, en definitiva, la velocidad del pulso de salida (pin COIN). Esta velocidad de pulso se encuentra entre los 100 milisegundos (SLOW/ velocidad lenta / pulso largo), 50 milisegundos (MEDIUM / velocidad media / pulso medio) y 30 milisegundos (FAST / velocidad rápida / Pulso corto). En lo personal siempre trabajo con 100 milisegundos (SLOW), ya que tras varias pruebas es la velocidad más correcta para trabajar con nuestro Arduino.

Interruptor para las velocidades del pulso

Con el potenciómetro de la parte superior del monedero, se ajusta la tolerancia de aceptación de monedas, para una aceptación más o menos estricta (STRICT / más estricta o SLACK / menos estricta).

Potenciómetro de aceptación de monedas

El funcionamiento del programa es muy simple, es decir, vamos a utilizar la interrupción 0 de Arduino (INT 0), que es la que se va a producir a través del pin digital 2 de Arduino, al que le hemos conectado la señal “COIN” del monedero electrónico, por lo tanto, cada vez que se detecte en el monedero una moneda de 50 céntimos de Euro, este manda una señal de nivel alto (HIGH) a Arduino, para que se produzca la interrupción del sistema y se ejecute la Rutina de Servicio a la Interrupción (ISR) que es donde tenemos programado que se incremente en una unidad la cantidad de créditos. Por otro lado si presionamos el pulsador con conexión PULL-DOWN, es decir, cambia de nivel bajo (LOW) a alto (HIGH) cada vez que lo pulsemos (aunque a estas alturas ya hemos trabajado multitud de veces con este recurso) para disminuir en una unidad el número de créditos. Como el programa está refrescando constantemente los valores del display LCD 1602, en todo momento tendremos un valor actualizado de los créditos con los que contamos. Por último cabe decir que el display LCD 1602 le hemos conectado a nuestro Arduino a través de comunicación I2C, soldándole a sus pines el módulo LCM 1602 I2C V1 como ya hemos visto también en POST anteriores.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Monedero electrónico simple (marca SG).

· Módulo LCM 1602 I2C V1.

· Display 16x2 LCD 1602.

· Pulsador.

· Resistencia de 10KΩ.

· Fuente de alimentación regulada de 12VDC.

· Monedas de EURO de diferente denominación.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Balanza digital de hasta 20Kg con celda de carga y transmisor HX711

noreply@blogger.com (Mariano del Campo) — Thu, 02 Jun 2016 16:30:00 +0000

En el POST de hoy vamos a trabajar con una celda de carga de 20Kg, un transmisor de celda de carga HX711, un display LCD 1602, frecuentemente utilizado a lo largo de todo el BLOG y por último una estructura que fabricaremos en “DM”, que no es más que un tipo de aglomerado de madera muy resistente, para crear una precisa y práctica balanza digital capaz de pesar elementos de hasta 20Kg. Para comenzar este proyecto es muy interesante conocer que es y para que se utiliza la celda de carga, además de ver por qué es necesario utilizar un transmisor de celda de carga HX711 para comunicar la celda de carga con nuestro Arduino y que mediante el mismo podamos interpretar las señales eléctricas recibidas para mostrar a través del LCD 1602 el peso real de los elementos que nos interesen.

Una celda de carga es un transductor utilizado para convertir una fuerza en una señal eléctrica. Esta conversión empieza a partir de un dispositivo mecánico, es decir, la fuerza que se desea medir, deforma la galga extensiométrica y por medio de medidores de deformación, que son pequeños patrones de resistencias utilizados como indicadores de tensión, obtenemos una señal eléctrica con la cual podemos obtener el valor de la fuerza. Los medidores están unidos a la viga que se deforma cuando se aplica peso, a su vez, deformando el indicador de tensión. Cuando se deforma el medidor de deformación la resistencia eléctrica cambia en proporción a la carga. Esto se logra por medio de un puente de Wheastone, el cual se utiliza para medir resistencias desconocidas mediante el equilibrio de “brazos” del puente. Estos están construidos por cuatro resistencias que forman un circuito cerrado. En el caso de las celdas de carga las resistencias son los medidores de deformación. La celda de carga es ideal para poder medir variaciones sobre presión en una superficie o como simple transductor para medir un peso de algún elemento en contacto con el dispositivo, como es en nuestro caso. En este POST utilizaremos una celda de carga de 20Kg que es el valor máximo que podrá pesar nuestra balanza digital.

Celda de carga de 20Kg

El transmisor de celda de carga HX711 es una interface entre la celda de carga y nuestro Arduino, permitiendo poder leer el peso de manera sencilla. Internamente se encarga de la lectura del puente de Wheastone formado por los medidores de deformación de la celda de carga, convirtiendo la lectura analógica en digital con su conversor A/D interno de 24 bits. La comunicación con nuestro Arduino se realiza a través de los pines SCK (Reloj) y DT (Datos) que el transmisor de celda de carga HX711 tiene como SALIDAS.

Transmisor de celda de carga HX711

Por otra parte las ENTRADAS del transmisor de celda de carga HX711 van cableadas a la celda de carga de la siguiente manera:

- Pin E+ del transmisor HX711 à Cable Rojo de la celda de carga de 20Kg.

- Pin E- del transmisor HX711 à Cable Negro de la celda de carga de 20Kg.

- Pin A- del transmisor HX711 à Cable Blanco de la celda de carga de 20Kg.

- Pin A+ del transmisor HX711 à Cable Verde de la celda de carga de 20Kg.

Como se ha mencionado con anterioridad, toda la estructura de la balanza digital está fabricada en “DM”, que es un aglomerado elaborado con fibras de madera aglutinadas con resinas sintéticas mediante fuerte presión y calor, en seco, hasta alcanzar una densidad media, ideal para resistir grandes esfuerzos con un espesor reducido. Cabe decir que las uniones realizadas entre las tablas de DM o entre la celda de carga y las tablas de DM se realizan mediante tirafondos de 3mm de diámetro en diferentes longitudes y cabeza plana, además de aplicar adhesivo de contacto de secado rápido en todas las superficies a unir. Como se puede observar en la siguiente imagen, la celda de carga está dotada de una parte hueca (parte central de la celda de carga), que tiene que quedar en suspensión para su correcto funcionamiento, además hay que tener en cuenta que el sentido de la flecha indica la dirección de la fuerza o peso a aplicar a la hora de instalar la celda de carga dentro de la estructura de DM.

Despiece y montaje de la estructura de la balanza digital

Para programar correctamente nuestro Arduino y poder visualizar el peso real de los elementos que nos interesen a través del LCD 1602, lo primero que tenemos que hacer es cargar el programa llamado “Balanza_digital_calibrado.ino” para calibrar la balanza digital, que consiste básicamente en hallar el valor de la escala que se usará, es decir, hallar el factor de conversión para convertir el valor de lectura en un valor con unidades de peso. La escala es diferente para cada celda y cambia de acuerdo a la forma de instalar, al peso máximo o modelo de celda de carga, incluso así se trate del mismo modelo de celdas no necesariamente tienen el mismo valor de escala. Primero necesitamos conseguir un objeto con un peso conocido, en otras palabras, debemos saber el peso real del objeto que vamos a poner sobre la balanza digital. Se recomienda que el peso conocido sea cercano al valor máximo del rango de trabajo de la celda de carga. En nuestro caso usaremos un peso de 8Kg pues nuestra celda es de 20Kg, y por mi casa no he encontrado un peso conocido mayor.

Después de poner el peso en la balanza, a través del monitor serial se mostraran las lecturas del peso, son lecturas sin escalar, por lo que les deben aparecer números grandes. Muy importante es que el programa comience a funcionar sin el peso colocado en la balanza digital, pues al inicio de programa se calcula la tara. Posteriormente tendremos que abrir el monitor serie del IDE de Arduino, esperaremos a que el programa reste la tara, para finalmente poner el objeto de 8Kg (o el peso conocido más cercano a 20Kg que encontremos por casa) y así obtener una serie de valores a través del monitor serie.

Monitor serie

Con uno o el promedio de estos valores, que en mi caso he utilizado el valor 858000 para redondear, calculamos el valor de la escala que utilizaremos con la siguiente formula:

Fórmula para el cálculo de la ESCALA

Con este dato ya obtenido pasamos a programar el sketch que vamos a utilizar para pesar llamado “Balanza_digital_final.ino”, únicamente tendremos que sustituir la cantidad entre paréntesis de la línea de código balanza.set_scale(107250) por el valor que hayamos obtenido nosotros, para que la balanza digital nos pese correctamente. Una vez modificado el valor, validaremos y cargaremos el programa en nuestro Arduino. Una vez que se esté ejecutando el programa en nuestro Arduino debemos de esperar unos instantes hasta que se quite la tara, para que posteriormente aparezca a través del LCD 1602 el peso de cualquier elemento que pongamos sobre la balanza digital, siempre y cuando este no exceda de los 20Kg.

Para realizar los dos programas anteriormente mencionados nos ayudaremos de las funciones ya programadas y definidas para trabajar con el transmisor de celda de carga HX711, que vienen incluidas dentro de la librería #include”HX711.h” que os podréis descargar desde uno de los primeros POST de este BLOG. A continuación os muestro una descripción de las principales funciones con las que se trabaja:

· HX711(byte PinData, byte PinClock): Es el constructor del objeto HX711, se puede trabajar con cualquiera de los pines.

· void tare(byte n): Establece el peso actual como el peso de tara, n indica el número de lecturas que se realizan para obtener la tara, por defecto n=10;

· void set_scale(float scale): Establece el valor de la escala, que es el factor de conversión para convertir valor de lectura en un valor con unidades de peso. Por defecto es scale = 1;

· long read(): Espera hasta que el dispositivo esté listo y devuelve la lectura del ADC del HX711.

· long read_average(byte n): Realiza n veces la lectura del ADC y devuelve el promedio.

· double get_value(byte n): Devuelve el valor actual restando el peso de tara. Equivalente a (read_average() - OFFSET) . Si se especifica un valor de n, devuelve el promedio de n lecturas.

· float get_units(byte n): Devuelve el valor actual restado del peso de tara y dividido por la escala. Es equivalente a (get_value()/SCALE). Si se especifica un valor de n, devuelve el promedio de n lecturas.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Celda de carga de 20Kg.

· Transmisor de celda de carga HX711.

· Módulo LCM 1602 I2C V1.

· Display 16x2 LCD 1602.

· Estructura de la balanza digital:

o Tablas de DM:

§ 1 de 150x200mm, 1 de 60x75mm y 1 de 60x60mm.

o Tirafondos de cabeza plana:

§ 4 de 3x20mm, 2 de 3x25mm y 2 de 3x35mm.

o Adhesivo de contacto de secado rápido.

· Protoboard.

· Cables de conexión.

Código del programa:

· Balanza_digital_calibrado:

Descarga del Programa para el calibrado

· Balanza_digital_final:

Descarga del Programa final

Video:

Comunicación RS-485 simplex entre dos Arduinos con módulos MAX485

noreply@blogger.com (Mariano del Campo) — Wed, 18 May 2016 09:55:00 +0000

Hoy os voy a mostrar cómo trabajar con uno de los estándares de comunicación en bus de la capa física del Modelo OSI denominado RS-485, muy utilizado en las comunicaciones industriales debido a su robustez, fácil implementación y buenas prestaciones. Está definido como un sistema de bus diferencial multipunto, es ideal para transmitir a altas velocidades sobre largas distancias (35 Mbit/s hasta 10 metros y 100 kbit/s en 1200 metros) y a través de canales ruidosos, ya que el par trenzado reduce los ruidos que se inducen en la línea de transmisión, admitiendo 32, 128 o 254 estaciones en un solo par. La transmisión diferencial permite alcanzar mayor distancia con una notable inmunidad al ruido, siempre que el bus de comunicación conserve las características de bus balanceado dando la posibilidad de una configuración multipunto. La norma RS-485 indica que cada uno de sus nodos se conecta a la línea de transmisión formando una cadena conocida como topología en Bus. Cada elemento o nodo de la red (transmisor o driver y receptor) se conecta a la línea de transmisión mediante unos cables de enlace cortos. Por sus características físicas, este tipo de topología es el más sencillo que se puede implementar. La interface con la topología tipo Bus puede ser diseñada para una comunicación unidireccional (simplex), dual simultanea (full-duplex) o dual no simultánea (half-duplex).

Ejemplo de comunicación industrial con protocolo RS-485

El módulo MAX485 RS485-TTL tiene acceso a todos los pines del MAX485 que incorpora y contiene todos los componentes adicionales, tales como resistencias o condensadores, necesarios para su correcto funcionamiento y control. Los pines A y B se pueden conectar también desde la bornera. Este módulo nos permite establecer una interfaz RS-485 a Serie TTL para trabajar con los pines RX y TX de Arduino como si de una simple comunicación serie se tratara pero respetando el protocolo de comunicación RS-485. Las salidas A y B son por donde se envían los datos, B es la negación de A, es decir, se envían los mismos datos pero en la línea B están negados, de esta forma se pueden restar ambas señales y eliminar el ruido y quedarnos solo con la señal de datos. El encargado de esta transmisión diferencial es el integrado MAX485.

Módulo MAX485 RS485-TTL

En este POST vamos a comunicar dos Arduinos de manera unidireccional (simplex) a través de módulos MAX485 RS485-TTL, por lo que en este caso un Arduino se comporta solo como transmisor y el otro solo como receptor, a nivel de programación es como si estuviéramos trabajando con una comunicación serial, pero en un solo sentido (uno envía y el otro solo recibe datos). El modulo conectado al Arduino transmisor solo va a trabajar como transmisor, es decir, se tienen que conectar a +5V los pines RE y DE para que el modulo sepa que las salida A y B se van a comportar como salida de datos. Desde el Arduino transmisor se envía el valor mapeado del potenciómetro (de 0 a 254), dependiendo de la posición en la que se encuentre su mando de control, desde el pin TX de Arduino hacia el pin DI (Data Input) del módulo y este transmitirá los datos por los pines A y B hacia el módulo del Arduino Receptor. El módulo conectado al Arduino receptor solamente va a trabajar como receptor y para ello debemos de conectar los pines RE y DE del módulo a GND, y los datos recibidos por A y B estarán presentes en el pin RO (Receiver Output) del módulo, por lo que conectando el pin RO del módulo al RX de nuestro Arduino receptor podemos leer el dato recibido y en función de su valor (entre 0 y 254) brillará un LED, que tenemos conectado a una salida digital PWM de Arduino, con una intensidad concreta, desde permanecer apagado hasta conseguir un brillo máximo del LED cuando movemos el mando del potenciómetro del Arduino transmisor de un límite mecánico al otro. Solo dos cables (salidas A y B de los módulos MAX485 RS485-TTL) unirán a los Arduinos, pero teniendo en cuenta que si la distancia es larga se recomienda usar cable trenzado para eliminar interferencias como el ruido. Se han habilitado a través de la librería nuevas conexiones serie TX (pin 3) y RX (pin 2) dentro de los programas que cargaremos a los dos Arduinos para poder dejar libres las conexiones TX (pin 1) y RX (pin 0) que trae configuradas el Arduino por defecto para comunicarse a través del puerto serie, puesto que son utilizadas a la hora de cargar los programas y de comunicarse con el monitor serie del IDE de Arduino, produciendo ciertas incompatibilidades al comunicarse con el módulo MAX485 RS485-TTL. Para una mayor información os recomiendo revisar los comentarios realizados dentro de cada uno de los programas.

Lista de Materiales:

· 2 Arduinos UNO Rev.3.

· Cable USB tipo A-B.

· 2 Módulos MAX485 RS485-TTL.

· Potenciómetro lineal de 10KΩ.

· Resistencia de 220Ω.

· LED de 3mm de cualquier color (válido de 5mm también).

· Batería de 12VDC (DC 12300).

· Batería de 9VDC con clip para Jack de 3,5mm macho.

· 2 Protoboards.

· Cables de conexión.

Código del programa:

· Transmisor_simplex_RS485:

Descarga del Programa del Transmisor

· Receptor_simplex_RS485:

Descarga del Programa del Receptor

Video:

Detector de metal con sensor de proximidad inductivo PNP y un zumbador

noreply@blogger.com (Mariano del Campo) — Tue, 03 May 2016 14:11:00 +0000

En el POST de hoy vamos a trabajar con el sensor de proximidad inductivo PNP LJ12A3-4-Z/BY, capaz de detectar todos los metales que sean de tipo ferroso, que son aquellos que en su composición tienen principalmente hierro, como el acero (mezcla de hierro con un poco de carbono ) o el hierro puro. Este tipo de sensores de proximidad es muy utilizado en la industria para contar objetos metálicos o para conocer su posición en un determinado momento, mejorando así la velocidad de los procesos industriales sin que tenga que intervenir ningún operario.

Sensor de proximidad inductivo PNP LJ12A3-4-Z/BY

El funcionamiento de este sensor es muy simple, es decir, en presencia de metales ferrosos la corriente que circula por el hilo conductor, va a generar un campo magnético alrededor del mismo conmutando la salida del sensor. Como la salida del sensor es normalmente abierta (NO) siempre se encontrará a NIVEL BAJO hasta que conmute cambiando a NIVEL ALTO (salida PNP, si fuese NPN trabajaría al revés, es decir, pasaría de NIVEL ALTO a NIVEL BAJO en la conmutación), que es cuando se activará el zumbador que tenemos conectado a nuestro Arduino. A continuación os muestro las principales características de este sensor.

Principales características del sensor LJ12A3-4-Z/BY

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Sensor inductivo de proximidad PNP (LJ12A3-4-Z/BY).

· Zumbador piezoeléctrico (Buzzer).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Control de una hélice con motor DC y driver L9110H

noreply@blogger.com (Mariano del Campo) — Fri, 29 Apr 2016 10:41:00 +0000

Hoy os voy a mostrar cómo controlar tanto la velocidad como el sentido de giro de una hélice motorizada mediante el uso del driver L9110H, utilizado habitualmente para el manejo de pequeños motores DC que estén alimentados con voltajes comprendidos entre 2.5 - 12V, que en nuestro caso es un motor DC de 5V, y con una corriente máxima de 800mA. Este tipo de hélice con motor DC y driver L9110H es del fabricante “KEYES”, pudiéndose adquirir en algunas de las tiendas de electrónica online existentes en el mercado bajo el nombre de “Fan motor” a un precio que ronda los 6€.

Fan Motor de “KEYES”

Este sistema viene ya montado y soldado en un PCB ofreciéndonos 4 pines de conexión, dos de ellos para la alimentación (+VCC y GND), y los otros dos para el control del motor DC de 5V (INA e INB). El pin INA se utiliza para variar la velocidad del motor DC mediante pulsos PWM, por lo que deberemos de conectarlo a un pin digital de Arduino que permita este tipo de salida digital pulsada (en el programa de control se utiliza el pin digital 9). Por otro lado el pin INB se utiliza para cambiar el sentido de giro del motor, es decir, cuando este pin esté a nivel BAJO (LOW) el motor girará en un sentido y cuando esté a nivel ALTO (HIGH) girará en el sentido contrario (en el programa de control se utiliza el pin digital 8). El programa de control lo que hace es desplegar un MENU a través del monitor serie del IDE de Arduino, para que nosotros a través del mismo, seleccionemos una opción como se puede observar en la siguiente imagen.

Monitor Serie

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Fan Motor (KEYES).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Caudalímetro con sensor de flujo YF-S201 y LCD 2004

noreply@blogger.com (Mariano del Campo) — Fri, 15 Apr 2016 17:08:00 +0000

En el POST de hoy os voy a enseñar cómo medir el caudal de agua en L/hora que atraviesa la alcachofa de nuestra ducha, así como la cantidad de agua que gastamos cada vez que nos duchamos, para ello, vamos a montar y programar un sencillo caudalímetro basado en el sensor de flujo YF-S201, un display LCD 2004 para poder visualizar los valores a tiempo real y una serie de elementos auxiliares necesarios para que le llegue el caudal de agua a nuestro sensor.

Sensor de flujo YF-S201

El sensor de flujo YF-S201 está constituido por una carcasa de plástico, un rotor de agua y un sensor de efecto Hall. El funcionamiento de este sensor es muy simple, es decir, en el rotor tiene un pequeño imán adherido para poder registrar una vuelta cada vez que pasa por el sensor magnético de efecto Hall que hay en el otro lado del tubo, generándose pulsos de salida a una velocidad proporcional a la del flujo. En la parte posterior del sensor hay una flecha para indicar la dirección del flujo. Cada pulso en la salida del sensor equivale aproximadamente a 2,25 mililitros. Una de las cosas a tener en cuenta es que no es un sensor de precisión, por lo que la frecuencia del pulso varía un poco dependiendo de la velocidad de flujo, la presión del fluido y la orientación del sensor, necesitándose una cuidadosa calibración si se requiere más que un 10% de precisión. A continuación os muestro algunas de las características más relevantes de este sensor.

Tabla de características del sensor de flujo YF-S201

La salida del sensor (cable amarillo) la vamos a conectar a nuestro Arduino para que mediante una correcta programación podamos visualizar a través del LCD 2004 el caudal que sale por nuestra ducha en L/hora, además del consumo de agua en litros que hemos realizado en un determinado espacio de tiempo, por ejemplo, mientras nos duchamos (el cable rojo a +5V y el negro a GND de nuestro Arduino). Como la señal del pulso de salida es una simple onda cuadrada es muy fácil de registrar mediante interrupciones, para posteriormente convertir los pulsos en caudal. Según la hoja de datos del fabricante, por cada litro de agua que pasa por el sensor obtenemos aproximadamente 450 pulsos, entonces:

Esto quiere decir que si tenemos la frecuencia (pulsos por segundo), simplemente lo tenemos que dividir entre 7.5 para obtener el número de L/min. Para el caudal en L/hora tenemos que multiplicar la frecuencia por 60 minutos que tiene una hora.

La instalación del sensor a nuestra ducha es muy sencilla, lo primero que tenemos que hacer es dejar libre de conexiones el grifo de la ducha, para enroscar allí un extremo de la manguera con conexiones hembra de ½”, conectando el extremo libre de la manguera a la entrada del sensor. Por último en la salida del sensor conectaremos la manguera con la alcachofa que habíamos retirado anteriormente del grifo de la ducha. El sensor en ambos extremos tiene roscas macho estándar de ½”, lo que nos facilita la conexión. También es muy recomendable aplicar teflón en cada uno de los extremos del sensor para evitar posibles fugas de agua.

Caudalímetro con Arduino UNO

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Sensor de flujo YF-S201.

· Manguera con conectores hembra de ½”.

· Alcachofa de ducha con manguera y conector hembra de ½”.

· Módulo LCM 2004 I2C V1.

· Display 20x4 LCD 2004.

· Teflón.

· Batería de 12VDC/3000mAh (DC12300).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Reloj en tiempo real Tiny RTC I²C con LCD 2004

noreply@blogger.com (Mariano del Campo) — Tue, 12 Apr 2016 15:05:00 +0000

El Tiny RTC I²C, es uno de los diferentes relojes en tiempo real con comunicación I²C que nos podemos encontrar en el mercado actual. Está compuesto por un RTC DS1307, una memoria EEPROM 24C32N y una batería CR2032 de 3V, gracias a ello es capaz de almacenar los datos y de seguir en funcionamiento aunque lo desconectemos de la alimentación de nuestro Arduino, y por lo tanto, cuando volvamos a conectarlo, mantendrá intacta tanto la hora como la fecha que le hayamos introducido mediante programación, aunque siempre que estemos trabajando con él es muy recomendable mantenerlo correctamente alimentado.

Tiny RTC I²C

Los valores tanto de hora como de fecha, les vamos a poder visualizar a través de un display LCD 2004, que no es más que un simple LCD que cuenta con cuatro líneas en las que se pueden mostrar hasta 20 caracteres en cada una de ellas. Tanto el LCD 2004 como el RTC van a compartir los pines SCL y SDA para conectarse con nuestro Arduino mediante comunicación I²C, aunque podríamos incluir en nuestros proyectos hasta 128 dispositivos gracias a este protocolo de comunicación, siempre y cuando respetemos la dirección que tenga asignado cada uno de ellos.

Otra cosa muy importante a recordar es que dentro de la programación, exactamente en la línea “LiquidCrystal_I2C lcd(0x20, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);”, donde pone 0x20, es justo la dirección que va a tener nuestro LCD 2004. Dicha dirección se obtiene midiendo el valor de los pines de dirección A0, A1 y A2, que están justo detrás del módulo LCM 2004 I2C V1 conectado al LCD 2004, con un potenciómetro, que en mi caso están todos conectados a GND (A0=0, A1=0 y A2=0) como se puede apreciar en la siguiente imagen.

Configuración de los pines A0, A1 y A2 (direcciones) en el LCD 2004

El programa simplemente cargará automáticamente la hora y la fecha que tengamos ajustada en nuestro PC al Tiny RTC I²C a través de la conexión serie USB de nuestro Arduino y gracias al uso de la librería "RTClib.h", una vez que comience la ejecución del programa, se mostrará los valores a través del LCD 2004. A parte de mostrarnos la hora y la fecha en tiempo real, este sistema nos permite poder crear diferentes alarmas y eventos en función del instante de tiempo que deseemos, siempre que se contemple dentro de la programación y tengamos correctamente conectado el hardware externo que necesitemos, por ejemplo, que a las 18:00:00h del día 14/04/2016 se encienda una bombilla a través de un Relé conectado a uno de los pines digitales de salida de los que nuestro Arduino dispone, para que posteriormente se apague a las 18:30:00h. Para más información debéis revisar el POST donde se explica detenidamente el manejo de los Relés.

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· RTC DS1307.

· Batería de 3V CR2032.

· Módulo LCM 2004 I2C V1.

· Display 20x4 LCD 2004.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Registrando temperatura ambiente con LM35 y lector de tarjetas micro SD

noreply@blogger.com (Mariano del Campo) — Thu, 07 Apr 2016 16:34:00 +0000

Hoy os traigo un simple y económico sistema para registrar los valores de temperatura que hay en un determinado lugar a lo largo del tiempo, para ello, vamos a utilizar un sensor de temperatura LM35 y un módulo lector de tarjetas micro SD, que junto con nuestro Arduino y una sencilla programación lograremos crear un robusto dispositivo para el registro climático. El LM35 es un sensor de temperatura de muy bajo coste con una precisión calibrada de 1 °C. Su tensión de salida es lineal y proporcional a la temperatura, por lo que cada grado Celsius equivale a 10 mV, abarcando un rango de medición desde -55 °C (-550mV) hasta 150 °C (1500mV). Debido a su baja corriente de alimentación (60 μA) se produce un efecto de auto calentamiento muy reducido, además se encuentra en el mercado en diferentes tipos de encapsulado, el más común es el TO-92, utilizado también por los transistores de baja potencia. El LM35 no requiere de circuitos adicionales para su correcto funcionamiento, la baja impedancia de salida y su precisa calibración interna hacen posible su fácil instalación a nuestro Arduino.

Sensor de temperatura LM35

Este dispositivo consta de tres pines de conexión, los dos de los extremos para la alimentación (+5V y GND) y el central para el voltaje de salida “Vout”, que será el pin que conectaremos a la entrada analógica A0 de nuestro Arduino para que a través de su conversor A/D de 10 bits de resolución podamos obtener ciertos valores con los que poder operar y de esta manera obtener la temperatura real que está detectando el sensor en cada momento. Partiendo de la premisa de que 1 °C equivale a 10mV en Vout, lo primero que hacemos es obtener el valor que nos entrega el conversor A/D tras la lectura del pin Vout del sensor, después multiplicamos este valor por la precisión para obtener el voltaje real y por último dividimos el voltaje entre los 10mV para obtener los grados centígrados (°C), quedando la siguiente fórmula matemática.

A partir de aquí lo que nos interesa conocer es que nuestro Arduino puede leer y escribir datos en tarjetas micro SD a través de un módulo específico, pero no formatearlas, debido a ciertas limitaciones de la librería #include que utilizamos, aunque como siempre estas limitaciones o especificaciones pueden cambiar en el futuro, pero es importante que las tengáis en cuenta. Por ahora solo soporta tarjetas micro SD en formato FAT16 y FAT32, en principio si usas FAT32 deberías poder usar hasta una tarjeta de 32Gb, además los nombres y archivos quedan limitados al viejo formato 8.3, es decir, nombre de 8 caracteres y extensiones de tres, y nada de acentos en los nombres, ni nuestra querida letra “Ñ”, ni espacios en blanco, en definitiva nada que no sean letras y números, sin signos raros. Si usas Windows en cualquier versión, puedes introducir la tarjeta micro SD en un adaptador SD o similar y formatearla desde el administrador de archivos, eligiendo la opción formatear y en sistema de archivos debes seleccionar FAT32 (predeterminado), manteniendo en las opciones de formato el rápido. También debéis de conocer que la librería puede no escribir inmediatamente los datos que le envías a la tarjeta micro SD, y para asegurarse de que es así, debes hacer una llamada a flush (Vaciar) o close (Guardar y cerrar).

Lector de tarjetas micro SD

Para finalizar os tengo que decir que el módulo lector de tarjetas micro SD se conecta a nuestro Arduino mediante comunicación SPI, que no es más que uno de los protocolos de comunicación serie que soporta, además tenemos que cargarle el programa para que se escriba en la tarjeta micro SD cada 5 segundos el valor de la temperatura ambiente en un archivo llamado “LM35.TXT” (Si este archivo no existe lo crea y si ya existe añade los datos a continuación de los anteriores), cuyo contenido tendrá el siguiente aspecto.

Monitor serie del IDE de Arduino

A través del monitor serie del IDE de Arduino podremos ir visualizando la temperatura a tiempo real además de los distintos mensajes que irá enviando el programa en función del comportamiento del lector de tarjetas micro SD (Error al leer la tarjeta, valor almacenado correctamente, error al escribir en LM35.TXT…).

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Sensor de temperatura LM35.

· Módulo lector de tarjetas micro SD.

· Tarjeta micro SD genérica de 2GB.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Piano con teclado capacitivo TTP229 de 16 canales y un zumbador

noreply@blogger.com (Mariano del Campo) — Wed, 30 Mar 2016 14:34:00 +0000

Hoy os traigo un fabuloso piano táctil, realizado con un teclado matricial capacitivo TTP229 de 16 canales, mediante el cual vamos a poder enviar diferentes frecuencias al zumbador piezoeléctrico activo, para conseguir la escala de todas las notas musicales en diferentes octavas, en concreto desde la 2ª a la 6ª octava, o lo que es lo mismo desde los 65,40Hz hasta los 1975,53Hz. He modificado el teclado original con unas pegatinas que podéis descargar en el siguiente enlace, para que sepamos a que tecla corresponde cada nota musical y también poder reconocer las diferentes octavas.

Teclado matricial capacitivo TTP229 de 16 canales

Este teclado está basado en el sensor capacitivo TTP229 y se utiliza mucho como una buena alternativa a los teclados mecánicos existentes, proporcionando mayor durabilidad a nuestros proyectos en situaciones donde haya que realizar gran cantidad de pulsaciones. El teclado por defecto viene configurado en el modo de 8 teclas, estando las salidas de la 1 a la 8 mapeadas directamente al conector del teclado, pero cuando se requiere utilizar las 16 teclas, que es nuestro caso, es necesario la utilización de un “Jumper” que lleve a nivel BAJO el pin TP2/KYSEL para poder cambiar al modo de 16 teclas, configurándolas como nos apetezca con Arduino a través de comunicación I²C y por supuesto gracias al código de programación que le cargamos. Según la configuración de la siguiente imagen tendremos un teclado en modo de 16 teclas, salidas activas a nivel BAJO y sin multi-key (las teclas solamente se pueden pulsar de una en una).

Configuración del teclado matricial capacitivo TTP229 de 16 canales

Para poder comprender mejor el funcionamiento y el código de programación de este singular piano táctil, os tengo que comentar que el oído humano capta solamente frecuencias que estén por encima de los 20Hz y por debajo de los 20.000Hz (muy aproximadamente). Así pues, y con mucha suerte, sólo podemos oír unas 10 octavas como mucho, con doce notas cada una. Las 12 notas tienen distintas representaciones en el lenguaje musical (Do, Do#, Re, Re#, Mi, Fa, Fa#, Sol, Sol#, La, La# y Si), pero la diferencia de frecuencia entre cada nota y la siguiente es lo que las caracteriza, y lo que nos permite identificarlas. Además, las 12 notas de una octava, están separadas por lo que en música se denomina un semitono, y que es la mínima distancia tonal que puede haber entre dos notas cualesquiera (siempre hablando del esquema básico de la música occidental). Para finalizar esta pequeña introducción sobre las notas musicales me queda por comentaros que una melodía es una sucesión de "notas", que hacen vibrar el aire a frecuencias distintas, que es ni más ni menos lo que se pretende realizar en este POST, y que cada octava se extiende a través de un rango de frecuencias que es del doble del tamaño que el rango de frecuencias de la octava anterior como se puede observar en la siguiente tabla.

Frecuencia de las notas en las octavas de la 2ª a la 6ª

Una vez conectado el hardware y cargado el código en nuestro Arduino, podemos ir pulsando las diferentes teclas para componer nuestras propias melodías. Para saber en qué octava nos encontramos en cada momento se ha dotado al sistema de una serie de LEDS que se encenderán únicamente cuando estemos en la octava que les corresponda como se muestra a continuación.

Tabla de LEDS y Octavas

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Teclado matricial capacitivo TTP229 (16 canales).

· 5 LEDS de 3mm (blanco, verde, amarillo, rojo y azul).

· 5 Resistencias de 220Ω.

· Zumbador piezoeléctrico activo (Buzzer).

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video:

Detector de partículas de polvo en el aire con sensor GP2Y10

noreply@blogger.com (Mariano del Campo) — Tue, 22 Mar 2016 17:34:00 +0000

El sensor GP2Y10 de Sharp es especialmente efectivo detectando partículas muy finas de polvo en el aire, de hasta 0.5 micras, y se utiliza frecuentemente para detectar la calidad del aire en sistemas de purificación del aire o en sistemas de aire acondicionado. Este sensor de detección óptica está compuesto internamente por un diodo emisor de infrarrojos (IRED) y por un fototransistor, colocados diagonalmente de tal forma que son capaces de detectar las reflexiones de luz sobre las partículas de polvo en el aire.

Especialmente es eficaz para detectar partículas muy finas como las del humo de un cigarrillo, pudiéndose distinguir el humo del polvo de la casa mediante un patrón de impulsos basado en comprobar el voltaje de la salida (Vo) cada 10ms, averiguando cuantas veces se interrumpe la comunicación entre el IRED y el fototransistor, y por lo tanto conociendo la densidad y la concentración de partículas de polvo o humo que hay en un determinado instante.

Sensor de polvo SHARP GP2Y10

Se trata de un sensor de muy bajo consumo, entorno a los 20mA, que puede ser alimentado con un voltaje de hasta 7VDC. La salida es un voltaje lineal y proporcional a la cantidad de polvo detectado. La sensibilidad del sensor es de 0.5V por cada 0.1 mg/m³. Para conectarlo a nuestro Arduino, se deben de añadir una resistencia de 150Ω y un condensador de 220µF, formando un circuito RC serie como divisor de tensión, como se puede observar en la siguiente imagen.

Conexión correcta de la entrada del sensor

El IRED del sensor GP2Y10 que tenemos conectado al pin digital 2 de Arduino permanece activo durante 0,32ms, que es la suma de lo que la salida Vo tarda en estabilizarse para poder ser leída a través del pin analógico A0 (0.28ms), más los 0.04ms que la salida Vo se mantiene en su máximo valor. Posteriormente el IRED permanece desactivado durante los 9.680ms siguientes antes de repetirse la secuencia del pulso de control (10ms) del IRED como se muestra a continuación.

Secuencia del pulso de control del IRED

En este POST voy a utilizar el sensor GP2Y10, para obtener el voltaje en la salida Vo del sensor, además de los valores de concentración y densidad de partículas de polvo en el aire mediante unas fórmulas matemáticas cotejadas con los valores que se obtienen del medidor de calidad de aire profesional DC1100 que incluyo dentro de la programación. Todo ello va a poder ser visualizado a través de un display LCD 1602 que he conectado a Arduino a través de comunicación I²C.

Para realizar la simulación de una situación en la que el ambiente esté mucho más cargado de partículas de polvo que en mi habitación, he adherido el sensor GP2Y10 a un Tupperware, de un litro de capacidad, al que además he añadido un ventilador de 12VDC con conexión directa a la fuente de alimentación, para poder incluir harina u otro elemento que tenga pequeñas partículas a través del ventilador y que este las vaya recirculando a través del orificio del sensor GP2Y10 para obtener diferentes lecturas.

Sistema de detección de partículas de polvo en el aire

En la siguiente tabla podemos comprobar el voltaje de salida (en voltios) en función de la densidad del polvo (en mg/m³), que este sensor de SHARP nos ofrece.

Gráfica de la Calidad del Aire

Para conocer la calidad del aire en cada momento nos podemos orientar por medio de la siguiente tabla, que está realizada respecto a la concentración de partículas de polvo en partes por millón (ppm) que hay en el aire:

Tabla de la calidad del aire

Lista de Materiales:

· Arduino UNO Rev.3.

· Cable USB tipo A-B.

· Módulo LCM 1602 I2C V1.

· Display 16x2 LCD 1602.

· Sensor detector de partículas GP2Y10 de SHARP.

· Resistencia de 150Ω.

· Condensador electrolítico de 10V y C=220µF.

· Ventilador de 12VDC 0.15A (C5010B12M).

· Fuente de tensión de 12VDC.

· Tupperware de 1L de capacidad.

· Protoboard.

· Cables de conexión.

Código del programa:

Descarga del Programa

Video: