Archivo de la categoría: Programación

Control de relés por enlace de 2,4 GHz – módulos NRF24L01 (Domótica 4)

La función de este artículo es dar ejemplos de comunicación inalámbrica entre dos placas Arduino, utilizando el módulo transceptor basado en el chip NRF24L01.

En la imagen se observa dos formatos de módulo transceptor, ambos con el chip NRF24L01. Este chip utiliza la banda de 2,4 GHz y puede operar con velocidades de transmisión de 250 kbps hasta 2 Mbps. Si se usa en espacios abiertos y, con menor velocidad de transmisión, su alcance puede llegar hasta los 100 metros. Para mayores distancias, hasta 1000 metros, existen módulos provistos con una antena externa en lugar de una antena trazada sobre la misma placa, como se observa en la imagen.

Con este sistema enviaremos comandos de texto que controlen un módulo de relés para manejar artefactos de 220V CA en una instalación de domótica. Para domótica es suficiente el alcance del módulo básico, pero se puede optar por la versión con antena incorporada, si es necesario.

En nuestro artículo Arduino: Comunicación inalámbrica con NRF24L01 están explicados y desarrollados en detalle varios usos del módulo NRF24L01 con un Arduino. Si no está familiarizado con un módulo como este, o si desea profundizar más en sus características y capacidades, recomendamos su lectura, aunque no es imprescindible para utilizar este diseño.

Para el control de las placas NRF24L01 para enlace de RF se utiliza la biblioteca RF24, totalmente compatible con las placas Arduino. En la página enlazada hay una explicación en inglés de cómo instalarla en su IDE de Arduino. Si no, puede leer las instrucciones a continuación (si ya conoce el procedimiento, saltee esta explicación):

Como es una librería obtenida del sitio GitHub, que es un repositorio de código para programadores, deberemos utilizar el método de instalación manual. Lo primero es descargar la librería en formato ZIP dentro de la carpeta que usted elija.

Una vez descargada debemos añadir la librería mediante el menú desplegable Programa >> Incluir Librería >> Añadir biblioteca .ZIP… Se abrirá un panel para buscar el ZIP en su disco rígido.

Una vez seleccionado el archivo éste será incluido. Cerramos el IDE de Arduino y cuando volvamos a abrirlo la librería ya estará disponible.

Circuito básico para el sistema

La biblioteca RF24 utiliza los pines estándar del hardware SPI (MISO, MOSI, SCK) que son, respectivamente, los pines digitales 12, 11 y 13 en la placa Arduino UNO. También se necesitan dos pines adicionales para controlar las funciones de selección del chip (CS) y habilitación del chip (CE).

Estos dos últimos pines pueden ser elegidos y designados por el usuario utilizando la función radio(ce_pin, cs_pin) de la biblioteca RF24; y se puede usar cualquier pin digital disponible.

El diagrama de conexiones de los módulos —que mostramos a continuación— es idéntico para las placas Arduino de ambos lados, transmisor y receptor. Observe con atención que la entrada VCC del módulo transceptor está conectada a la salida 3,3V del Arduino. No se equivoque con la alimentación poniéndola a 5V, porque el módulo resultaría dañado.

A continuación, le agregaremos a uno de los dos Arduino, que funcionará de receptor, un módulo de relés como los que hemos descrito y explicado en detalle en el artículo Módulos de relé y Arduino: Domótica (1). Recomendamos leerlo.

Sistema 1: Control utilizando el teclado de la computadora a través de Monitor Serie

La placa Arduino utilizada como transmisor estará conectada al puerto USB de la PC, o laptop, que utilizamos para programarlo y luego para enviar los comandos. El puerto USB alimentará la placa y el módulo transmisor.

El Arduino receptor puede estar conectado a cualquiera de los modos de alimentación adecuados: un cable USB conectado a un cargador estándar de 5V, o a un Power Bank para celular; una batería de 9V o una fuente regulada de 9V CC conectada al jack de entrada de alimentación de la placa Arduino o a su pin Vin.

El circuito del receptor se cableará de la siguiente manera a los módulos de relé:

Nota: en este circuito se alimentan los led emisores de los optoacoples desde la misma fuente de los relés. Para separar totalmente los circuitos, quitar el jumper entre VCC y JD-VCC y alimentar VCC desde los 5V de la placa Arduino.

Circuito del Sistema 1, con módulo de 2 relés

Criterio de control:

La lista de comandos es como sigue

a – Activa el relé 1 / a apaga el relé 1 al pulsar de nuevo
b – Activa el relé 2 / b apaga el relé 2 al pulsar de nuevo

Programa del transmisor

Programa del receptor:

Con esta disposición, la manera de controlar los relés es como sigue: abrimos el panel de Monitor Serie y tipeamos allí los comandos “a” o “b” para encender y apagar los relés.

La capacidad de control se puede ampliar utilizando módulos de mayor tamaño, por ejemplo de 4, 8 o 16 relés, y agregando las variables y líneas de programa para cada relé. Utilizaremos en esos casos las siguientes letras: “c”, “d” y así sucesivamente.




Sistema 2: Control con pulsadores, sin necesidad de computadora

Con el sistema desarrollado en la primera parte dependemos de una computadora para ingresar los comandos al Arduino transmisor, y esto puede ser impráctico.

Para agregar un nivel más de independencia al control, conectaremos unos pulsadores al circuito transmisor de Arduino que ya presentamos. Para que nos resulte más simple, vamos a utilizar los pulsadores de RESET con cable y conector que es posible rescatar por desarme del panel frontal de cualquier PC de mesa que haya sido descartada. Como este:

Si usted lo desea, puede reemplazar los dos pulsadores por cualquier modelo que usted disponga, como estos (colocados sobre una protoboard y conectados con cables), que además de venir en los kits básicos de Arduino, son muy comunes en electrónica:

Diagrama para el Sistema 2: pulsadores y módulo de 2 relés

Hemos agregado dos pulsadores de panel frontal de computadora de mesa, que ingresan por las entradas digitales 2 y 3. Los pulsadores los hemos nombrado como Puls1 y Puls2.

Con estos pulsadores podremos controlar el módulo de dos relés con el que trabajamos en este artículo hasta ahora, pero podríamos implementar este control con módulos de 8, 16, y hasta 32 relés.

El diagrama para esta parte del proyecto —siempre manteniendo el cableado básico del Arduino con el NRF24L01— es:

Criterio de control:

La lista de comandos es como sigue

Puls1 – Activa el relé 1 / Puls1 apaga el relé 1 al pulsar de nuevo
Puls2 – Activa el relé 2 / Puls2 apaga el relé 2 al pulsar de nuevo

Programa del transmisor:

Programa del receptor:

Presionando el pulsador 1 se activará el relé 1, y con una nueva pulsación se lo desactiva. El funcionamiento es igual para el pulsador 2 en conjunto con el relé 2.

Nota: Si usted halla un error, por favor háganos saber que lo ha encontrado. Gracias.

Artículos relacionados:

Módulos de relé y Arduino: Domótica (1)
Control con relés por interfaz serie: Domótica (2)
Control de relés con control remoto IR: Domótica (3)
Control de relés por enlace de 2,4 GHz – módulos NRF24L01: Domótica (4)
Descripción y funcionamiento del Bus I2C
¿Qué es la comunicación serie?



Control de relés con control remoto IR: Domótica (3)

En este ejemplo probamos el sistema de encendido de lámparas y equipos eléctricos conectados al voltaje de red manejado por un control remoto estándar (IR = Infrarrojo). Los comandaremos con teclas elegidas del control remoto, que primero identificaremos con un simple programa en Arduino.

Si usted desea leer con más detalle sobre control remoto con infrarrojo desde Arduino, le recomendamos el artículo Módulo transmisor de infrarrojo KY-005 (Kit de sensores Keyes 5) en nuestra página.

Para controlar artefactos con voltaje de red, usaremos las salidas normalmente abiertas de un módulo de relé. Si no conoce los módulos de relé que son estándar en la línea Arduino, recomendamos leer el artículo que inició esta serie Módulos de relé y Arduino: Domótica (1).

Utilizamos el mismo circuito armado en el artículo anterior: Control con relés por interfaz serie: Domótica(2). Le agregamos únicamente el sensor de recepción de infrarrojos, un sensor VS1838B proveniente de China, muy común en los kits de Arduino y en el mercado.

Se puede utilizar cualquier receptor de control remoto, incluso uno obtenido de desarme, si se tienen identificados sus pines de conexión.

El sensor no es un tan solo un fototransistor, posee un circuito integrado interno que filtra la señal de 38 KHz que modula el haz de infrarrojo, y es la que contiene los comandos de control. La salida de señal entrega una onda cuadrada de niveles TTL entre 0 y 5V. Existen modelos que entregan señal a niveles de 0 a 3,3V.

Es posible que usted encuentre el kit de la imagen que sigue en los sitios especializados, pero no es necesario. Alcanza con conectar el sensor al Arduino y utilizar un control remoto cualquiera de los que haya en su casa.

El sensor utilizado en este kit es, justamente, el VS1838B.


La que sigue es la manera más básica de conectarlo al Arduino, y es el circuito con el que comenzaremos a trabajar en las pruebas iniciales. La principal de ellas, obtener el listado de los datos que llegan al Arduino al presionar cada tecla.

Advertencia: cuando realiza proyectos que están conectados a la red eléctrica, realmente debe saber lo que está haciendo, de lo contrario, puede producirse un accidente. Este es un tema serio y queremos que esté seguro. Si no está 100% seguro de lo que va a hacer, por favor no toque nada.
¡Pregúntele a alguien que sepa!

El siguiente programa utiliza la biblioteca IRemote (creada por >shirriff). Consiste de un ciclo continuo que espera a que llegue un comando de control remoto, y entonces lo muestra por el Monitor Serie.

Con este programa en el Arduino y la pantalla del monitor serie abierta, pulsar cada tecla del control remoto para conocer sus valores. Es conveniente escribir los valores en un TXT para utilizarlos cada vez que sea necesario. Una lista como la que sigue, que corresponde a un control remoto de Direct TV. Los valores están en decimal.

48799: [guide]
45244: [active]
38057: [list]
33026: [exit]
57063: [back]
4985: [menu]
864: [info]
64187: [rojo]
14499: [verde]
49424: [amar]
59787: [azul]
57375 63414: [vol+]
53295 63414: [vol-]
31762: [guion bl]
16195: [enter]
65001: [prev]
61455: [mute]
6654: [flecha adel]
1579: [flecha atrás]
57094: [flecha derecha]
38068: [flecha izquierda]
22183: [select]
32630: [1]
23217: [2]
28078: [3]
59460: [4]
44135: [5]
37740: [6]
54067: [7]
11155: [8]
45264: [9]
29399: [0]
26583 26583 39270 63414: [on]
26583 26583 39270 63414: [off]
32895 63414: [tv input]

El control remoto del kit de sensor IR Keyes posee los siguientes valores en hexadecimal (puede diferir según el modelo):

0xFFA25D: CH-
0xFF629D: CH
0xFFE21D: CH+
0xFF22DD: PREV
0xFF02FD: NEXT
0xFFC23D: PLAY/PAUSE
0xFFE01F: VOL-
0xFFA857: VOL+
0xFF906F: EQ
0xFF6897: 0
0xFF9867: 100+
0xFFB04F: 200+
0xFF30CF: 1
0xFF18E7: 2
0xFF7A85: 3
0xFF10EF: 4
0xFF38C7: 5
0xFF5AA5: 6
0xFF42BD: 7
0xFF4AB5: 8
0xFF52AD: 9

Circuito para estas pruebas

Nota: en este circuito se alimentan los led emisores de los optoacoples desde la misma fuente de los relés. Para separar totalmente los circuitos, quitar el jumper entre VCC y JD-VCC y alimentar VCC desde los 5V de la placa Arduino.

Criterio de control

En este primer experimento hemos elegido como comandos para encender y apagar las salidas un conjunto de letras a enviar por línea serie. Para el relé 1 enviamos la letra “A” para encender, y la letra “a” para apagar. El relé 2 se enciende con la letra “B” y se apaga con la “b”. Y así sucesivamente si hubiese más relés. Para apagar todo al mismo tiempo elegimos enviar un “0” (cero).

La lista de comandos es como sigue:

Botón 1 – Activa el relé 1 / Botón 2 – Apaga el relé 1
Botón 3 – Activa el relé 2 / Botón 4 – Apaga el relé 2
Botón 0 – Apaga todos los relés

Programa 1 para dos relés

Copie el siguiente código en su IDE de Arduino y súbalo a su placa.

Advertencia: no es conveniente cargar código nuevo cuando su Arduino
está conectado al módulo de relés. Siempre quite la alimentación de 5V a este módulo.

Programa 2

En esta modificación de programa utilizamos una opción que nos permite usar una única letra de comando para encender y apagar. El «truco» consiste en alternar el estado del relé de encendido a apagado en cada recepción de la letra, utilizando una operación lógica NOT, que se representa con el símbolo !




Criterio de control

En este caso la lista de comandos es como sigue:
Botón 1 – Activa el relé 1 / Botón 1 apaga el relé 1 al pulsar de nuevo
Botón 2 – Activa el relé 2 / Botón 2 apaga el relé 2 al pulsar de nuevo

Programa 3:

El que sigue es un ejemplo para ampliar el manejo a 4 relés. Como observarán, sólo es necesario copiar y pegar y usar los códigos correspondientes.

En estos programas, la parte del código donde llega el código de comando está entre dos hileras de asteriscos. Reemplazando ese bloque de código es posible utilizar otros métodos de ingreso de datos para comandar la placa de relés.

Puede ser utilizando caracteres llegados desde una placa bluetooth, por I2C o SPI desde otro microcontrolador, un módulo de interfaz RS-485, o diversos sistemas basados en RF o enlaces de luz infrarroja, láser, etc.

En todos los casos, la comunicación de control se basará en caracteres de control ingresados por TX/RX u otro medio similar, incluyendo un ingreso directo implementado con entradas digitales y pulsadores.

El resto del código será siempre el mismo, la función con la estructura Switch…Case.

Las opciones las desarrollamos en la serie de artículos anteriores y los que siguen a este.

Artículos relacionados:

Módulos de relé y Arduino: Domótica (1)
Control con relés por interfaz serie: Domótica (2)
Control de relés con control remoto IR: Domótica (3)
Control de relés por enlace de 2,4 GHz – módulos NRF24L01: Domótica (4)
Descripción y funcionamiento del Bus I2C
¿Qué es la comunicación serie?



Control con relés por interfaz serie: Domótica (2)

En este ejemplo haremos un sistema de encendido lámparas y equipos eléctricos que funcionan con voltaje de red, y los controlaremos con caracteres enviados por línea serie a través del Monitor Serie del IDE de Arduino. Si usted desea leer con más detalle sobre la comunicación serie, le recomendamos el artículo ¿Qué es la comunicación serie? en nuestra página.

Para controlar artefactos con voltaje de red, usaremos las salidas normalmente abiertas de un módulo de relé. Si no conoce los módulos de relé utilizados usualmente en la línea Arduino, recomendamos leer el artículo previo de esta serie Módulos de relé y Arduino: Domótica (1).

Advertencia de seguridad

Antes de continuar con este proyecto, queremos recordarle que está tratando con la tensión de la red. Lea atentamente la siguiente advertencia de seguridad.

Advertencia: cuando realiza proyectos que están conectados a la red eléctrica, realmente debe saber lo que está haciendo, de lo contrario, puede producirse un accidente. Este es un tema serio y queremos que esté seguro. Si no está 100% seguro de lo que va a hacer, por favor no toque nada.
¡Pregúntele a alguien que sepa!

Partes necesarias

■ Módulo de 8 relés (o menos si lo desea, según la necesidad)
■ Arduino UNO
■ Cable USB
■ Cables, portalámparas, lámparas y tomacorrientes
■ Fuente de 5V 2A para alimentación de los relés

Esquemático

El sistema armado como prototipo se ve aproximadamente como en la foto que sigue:

Criterio de control

En este primer experimento hemos elegido como comandos para encender y apagar las salidas un conjunto de letras a enviar por línea serie. Para el relé 1 enviamos la letra “A” para encender, y la letra “a” para apagar. El relé 2 se enciende con la letra “B” y se apaga con la “b”. Y así sucesivamente para los 8 relés. Para apagar todo al mismo tiempo elegimos envíar un “0” (cero).

La lista de comandos es como sigue:

A – Activa el relé 1 / a – Apaga el relé 1
B – Activa el relé 2 / b – Apaga el relé 2
C – Activa el relé 3 / c – Apaga el relé 3
D – Activa el relé 4 / d – Apaga el relé 4
E – Activa el relé 5 / e – Apaga el relé 5
F – Activa el relé 6 / f – Apaga el relé 6
G – Activa el relé 7 / g – Apaga el relé 7
H – Activa el relé 8 / h – Apaga el relé 8
0 – Apaga todos los relés




Programa 1

Copie el siguiente código en su IDE de Arduino y prográmelo en su placa Arduino utilizando la opción «Subir».

Advertencia: no es conveniente cargar código nuevo cuando su Arduino
está conectado al módulo de relés. Siempre quite la alimentación de 5V a este módulo.

Colocamos entre dos hileras de asteriscos la parte del código donde se obtiene la letra de comando desde la línea serie. Reemplazando ese bloquecito de código es posible utilizar diversos métodos de ingreso de datos para comandar la placa de relés.

Por ejemplo utilizando caracteres llegados desde una placa bluetooth, por I2C o SPI desde otro microcontrolador, un módulo de interfaz RS-485, o diversos sistemas basados en RF (Wi-Fi, 2,4 GHz, etc.) o enlaces de luz infrarroja, láser, etc.

En todos los casos, la comunicación de control se basará en caracteres de control ingresados por TX/RX u otro medio similar de comunicación de caracteres, incluyendo una entrada paralela de 8 bits implementada por un puerto o con el uso de un chip auxiliar, y convertidos en una variable char (cuando es necesario).

El resto del código será siempre el mismo, la función con la estructura Switch…Case.

Por supuesto, usted puede iniciar sus pruebas con un circuito más sencillo, como el que sigue:

Todas las diferentes opciones de control las desarrollamos en detalle en la serie de artículos que siguen en la secuencia de publicación.

Programa 2

En esta modificación de programa utilizamos una opción que nos permite usar una única letra de comando para encender y apagar. El «truco» consiste en alternar el estado del relé de encendido a apagado en cada recepción de la letra, utilizando una operación lógica NOT, que se representa con el símbolo !

Criterio de control

En este caso la lista de comandos es como sigue:

a – Activa el relé 1 / a apaga el relé 1 al pulsar de nuevo
b – Activa el relé 2 / b apaga el relé 2 al pulsar de nuevo
c – Activa el relé 3 / c apaga el relé 3 al pulsar de nuevo
d – Activa el relé 4 / d apaga el relé 4 al pulsar de nuevo
e – Activa el relé 5 / e apaga el relé 5 al pulsar de nuevo
f – Activa el relé 6 / f apaga el relé 6 al pulsar de nuevo
g – Activa el relé 7 / g apaga el relé 7 al pulsar de nuevo
h – Activa el relé 8 / h apaga el relé 8 al pulsar de nuevo
0 – Apaga todos los relés

Artículos relacionados:

Módulos de relé y Arduino: Domótica (1)
Control con relés por interfaz serie: Domótica (2)
Control de relés con control remoto IR: Domótica (3)
Control de relés por enlace de 2,4 GHz – módulos NRF24L01: Domótica (4)
Descripción y funcionamiento del Bus I2C
¿Qué es la comunicación serie?



Manejo preciso de servos en Arduino: grados y milisegundos

Siendo miembro de grupos donde uno se entera de diversos problemas que se les presentaron a otros, a veces uno que resulta básico pero nunca se le ha presentado. En este caso se trató de un problema con el manejo de un servo que es el más vendido para los que se inician, y que a demás viene con los kits básicos de Arduino: el mini o micro servo SG90. El problema se presenta con la biblioteca Servo, pero también puede ocurrir con otro programa.

Me dije —ya que he manejado servos desde antes de que apareciera Arduino— que el problema debía ser una señal de posicionamiento incorrecta. Para entender bien de qué hablo, le pueden dar una mirada al artículo Servos: características básicas.

Una señal se comprueba con osciloscopio. Por suerte dispongo tanto de uno antiguo, con pantalla CRT, como de los que se pueden comprar ahora dentro de la familia Arduino, dotado de un pantalla TFT.

Después de algunas mediciones, me di cuenta de que el funcionamiento de la biblioteca Servo.h de Arduino deja un poco que desear, ya veremos por qué. Pero también ofrece una herramienta (en la función servo.attach) que, bueno, puede ser que no hayamos investigado y que por algo está disponible. Esto puede parecer algo para principiantes, pero hasta que uno empieza a tener estas complicaciones no se da cuenta, y luego de tener una comprensión mejor se logra usar la biblioteca de servo de Arduino con facilidad y dominando lo que hace.

Función write()

La razón de ser de una biblioteca es que uno se pueda desentender del manejo de programa específico de un elemento conectado a una placa de microcontrolador, y bueno, la biblioteca Servo de Arduino fue hecha para facilitar el control de los servos con un mínimo de código y complicaciones. La página de referencia de Arduino para el comando write(), que es parte de la biblioteca Servo.h, trae el siguiente código de ejemplo:

Este código de ejemplo le indica a un servo, conectado en este caso al pin 9, que se mueva a su posición central (que se define como 90°). Si se tratara de un servo de rotación continua, esto detendrá el movimiento del servo… pero este es tema para otro artículo.

Al correr este pequeño programa de demostración, los servos que se han conectado a ese pin se colocarán en sus posiciones centrales. Pero bueno, si lo consideramos desde la faceta mecánica, este punto medio puede que en algunos servos no sea exactamente el centro del arco completo del recorrido.

Un pulso con un ancho de 1.500 microsegundos debe corresponder a 90°, posición definida como el punto central del recorrido. Los servos más comunes aceptan entradas de 1.000 µs (1 ms) a 2.000 µs (2 ms), y 1.500 µs (1,5 ms) correspondientes a la posición central. Para un servo con un recorrido de 0 a 180°, esto sería 90°.





Ahora me toca aclarar que siempre utilicé valores en microsegundos para controlar servos, ya que la precisión del posicionamiento es mucho mayor. La biblioteca de servos permite usar el comando writeMicroseconds, que define el ancho de pulso exacto que se desea enviar a un servo. Los problemas comienzan cuando se usan ejemplos —ya escritos— en los que se utiliza el comando de escritura con un parámetro en grados (en el ejemplo de arriba, 90°).

Parecería lógico que un comando de escritura que instruye a un servo para que se ajuste a 90° debería enviar los mismos pulsos que un comando writeMicroseconds que envía pulsos de 1.500 µs. Es decir, write(90) y writeMicroseconds(1500) deberían enviar pulsos idénticos de 1500 µs. Pero resulta que esta suposición puede llevarnos a problemas.

Basándome en un ejemplo de internet, subí el siguiente código a un Arduino UNO R3, y visualicé las señales con osciloscopio.

Aquí es cómo se ven las salidas de los pines 3, 4 y 5:

■ El pin 3 de Arduino, fijado en 90°, da un pulso de 1,472 ms
■ El pin 4 de Arduino produce un pulso de 1.500 µs: 1,500 ms
■ El pin 5 de Arduino, fijado en 90°, da un pulso de 1,500 ms

El ancho de pulso se mide con el programa del osciloscopio. Por las dudas de que sea un problema técnico del osciloscopio, midiendo con un papel superpuesto sobre la pantalla se puede observar que sí existe la diferencia.

Y también al superponer señales, se observa la diferencia.

Esta diferencia entre 1.472 µs y 1.500 µs es pequeña y puede ser que ni siquiera implique diferencias en las posiciones del servo.

Si se observa la señal de servo3, que también programa el movimiento del servo con el parámetro de colocarse en posición de 90°, se nota que el ancho del pulso es correcto, 1.500 µs, el mismo que para servo2, para el que se fijó el pulso en forma directa en 1.500 µs.

El comando write(90) es el mismo en la primera y la tercera señal de servo, así que… ¿por qué uno envía un pulso de 1,472 ms y el otro 1,500 ms?

Arduino attach()

La respuesta está en el comando attach de la librería Servo. La página de referencia de Arduino enumera dos formas del comando:

La primera versión es el código mínimo que requiere un programa para designar un pin de E/S para el control de un servo. El segundo formato incluye dos parámetros muy importantes, pero opcionales, que determinan el rango mínimo y máximo de ancho de pulso para el programa. Es posible que en el ejemplo de arriba, el uso de límites en el segundo servo haya acomodado los valores de tiempo para que el tercero reciba un pulso correcto; pero al volver el bucle al principio y correr la función para 90º sin topes definidos, se vuelve a desacomodar.

Tanto en la página de referencia del comando attach en arduino.cc como en la propia biblioteca Servo, se establece claramente que las configuraciones mínimas y máximas predeterminadas son 544 y 2.400 µs, respectivamente. Pero como hay servos con diferentes extremos de carrera, se pueden fijar estos límites “opcionales” de ancho de pulso, que en realidad —para evitar dolores de cabeza y roturas de los servos— sería bueno acostumbrarse a usar.

Si uno está habituado a usar el comando writeMicroseconds en lugar de write, es posible que nunca haya pensado en los parámetros de ancho de pulso mínimo y máximo. Pero si se usa el comando write y se establecen las posiciones de los servos con ángulos y grados, entonces DEBEMOS definir explícitamente estos parámetros en los programas de Arduino que usan Servo.h, previa lectura de los datos indicados en la hoja de datos del servo utilizado. O si no, definiéndolos experimentalmente; porque hasta existen diferencias entre servos del mismo modelo.

Para definir los valores correctos de extremos de recorrido de un servo, puede utilizar un montaje como el que sigue, que se trata de una cartulina impresa y una aguja señaladora de cartón en el eje del servo, y enviar comandos con writeMicroseconds() hasta lograr el valor para el ángulo cero y el ángulo 180. El disco lo imprimí con un programa on-line muy útil para crear imágenes de discos de encoder.

Ingrese a esta página y pruebe primero con los siguientes parámetros:

Luego puede jugar con los valores hasta lograr el dibujo que usted necesite. Hay otras opciones en internet, incluso hay generadores de código postscript que se puede leer en Corel y que corren en Windows. Es cuestión de buscar.

Solución para la librería Servo

En el código de ejemplo, para la tercera señal de servo no dejaremos los anchos de pulso predeterminados y fijaremos los límites con los valores 1.000 y 2.000 µs. Esta es la razón por la que las señales del primero y tercer servo envían pulsos diferentes aunque se utilicen comandos idénticos.

Además de que no lograremos posicionamientos correctos de los servos con señales ligeramente descentradas, un servo podría interpretar de manera impredecible los anchos de pulso por encima o por debajo de los límites para los que fue diseñado. Los pulsos por debajo y por encima del límite también pueden dañar físicamente un servo.

Si un servo con recorrido de 0 a 180° está diseñado para responder a pulsos de 1.000-2.000 µs, interpretará 1.000 µs como 0°, y 2.000 µs como 180°. Pero, con un rango de límites de ancho de pulso predeterminado de 544 a 2.400 µs, el Arduino enviará una señal de ~1.000 µs para un ángulo de 44°. Un rango de pulsos de 1.000 a 2.000 µs se convertirá en un recorrido mecánico total de ~90° del eje del servo en lugar de 180°. Este y otros problemas potenciales pueden evitarse si se usan microsegundos en lugar de ángulos en grados, o si los parámetros opcionales de ancho de pulso para los extremos se definen en la configuración de pines para cada servo.

Es muy común que se dé por sentado que las bibliotecas de Arduino funcionan correctamente con sólo unos simples parámetros. La próxima vez que sus servos actúen de forma impredecible en un nuevo proyecto, vuelva a verificar que ha establecido los límites de ancho de pulso en la configuración del pin. Puede que con esto sea suficiente y se ahorre gran cantidad de tiempo.



Sistema para estacionamiento de un auto y para evitar acercarse demasiado a otro vehículo

Utilizando sensores ultrasónicos, los autos modernos nos dan una útil ayuda en el momento de maniobrar, especialmente al estacionarlos en espacios limitado. Podemos hacer nuestro sistema detector con un Arduino UNO y unos pocos componentes de bajo costo


Cómo funciona el sensor ultrasónico HC-SR04

El sensor ultrasónico HC-SR04 nos permite medir distancias por medio de emisión y rebote de ultrasonidos. Para medir distancias con Arduino podemos hacerlo de diferentes maneras.

Por orden de costo, hay un sensor que mide con el rebote de un láser; luego un sensor de infrarrojos que utiliza el paralaje del regreso de un haz de luz para calcular la distancia; y por último el más barato, el sensor ultrasónico HC-SR04, muy utilizado con Arduino, que utiliza la velocidad de propagación del sonido para medir distancia.

Para que no sea molesto al oído humano, utiliza ultrasonido a una frecuencia de 40 kHz. Estas ondas sonoras tienen una frecuencia muy por encima del espectro audible por los seres humanos.
El sensor funciona como un sonar, por rebote de la onda. El emisor del HC-SR04 envía un tren de ondas ultrasónicas cuando se activa la señal de disparo (trigger). Este sonido se refleja contra el objeto y retorna. El receptor detecta el momento en que retorna la onda y lo indica en la salida eco (echo).

Midiendo el tiempo de viaje podemos calcular la distancia.

La velocidad del sonido en la atmósfera terrestre es de 343,2 m/s a 20° C de temperatura, con 50% de humedad y a nivel del mar. Si necesitamos una gran exactitud, podemos agregar al diseño sensores BMP180 o BMP280, que nos aportan datos de altitud y temperatura, e incluso agregar un medidor de humedad, y por supuesto aplicar una fórmula más compleja. Pero para este diseño no necesitamos tanta precisión.

La fórmula de la velocidad es:

velocidad = espacio/tiempo

De donde despejamos la variable espacio, que necesitamos conocer:

espacio = velocidad x tiempo

La velocidad es conocida: la del sonido. El tiempo lo obtenemos con el sensor ultrasónico. Con ambos datos, podemos calcular la incógnita: a qué distancia se encuentra un objeto.

El zumbador o buzzer

Para simular correctamente un medidor de distancia de un automóvil utilizamos un buzzer (zumbador) pasivo. No hay que confundirlo con el zumbador activo, que tiene un oscilador interno, y por lo tanto una frecuencia fija y polaridad en sus pines de conexión.

Este reproductor no tiene un rango tan amplio de emisión de sonido como el del oído humano, ni mucho menos, pero es suficiente para diferenciar la distancia con frecuencias diferentes dentro de lo que es capaz de emitir. Además de los pequeños (como el de la foto), que vienen incluidos en los kits de Arduino, hay otros con mayor diámetro de diafragma (por ejemplo en el desarme de viejos modems), que ofrecen más volumen y un rango de frecuencias más amplio.

Sistema de alerta con leds y zumbador

Si bien al maniobrar no estaremos mirando hacia un indicador, sino atentos a los tonos de aviso, agregaremos al diseño un sistema de alerta visual. Nos dará una indicación aún más efectiva de si estamos cerca o lejos de un obstáculo. Con tres leds (verde, amarillo y rojo) conseguimos determinar si estamos a distancia sin riesgo, acercándonos, o en zona de peligro. Pero se podría ampliar la indicación con más leds y más comparaciones en el programa.

Componentes:

Arduino UNO, protoboard, cables para conexiones, resistores de 330 Ω, led verde, led amarillo, led rojo, sensor ultrasónico Arduino (HC-SR04), buzzer




Circuito:

Los resistores son de 330 Ω y van en serie con los LEDs. El sensor ultrasónico se conecta a dos pines digitales, uno para el trigger o disparador y otro para el echo, o receptor. El buzzer se conecta a una salida PWM y a GND. La salida PWM entregará distintas frecuencias según la indicación del programa, por medio de la función tone().

Programando el detector de distancia

Diagrama del programa

Los umbrales para la decisión se fijan como constantes, uno para cada situación. Podemos medir la distancia con una regla y determinarlos.

■ UmbralAlejado: está en zona verde desde 50 cm a 30 cm.
■ UmbralMedio: está en zona amarilla, desde 30 cm a 10 cm.
■ UmbralCerca: está en zona roja, menos de 10 cm.

Estos umbrales no son definitivos: se pueden cambiar a gusto del usuario.

El programa debe analizar la medición dividida en 4 zonas: fuera de rango (más de 50 cm, ninguna indicación), entre 50 cm y 30 cm (zona verde), entre 30 cm y 10 cm (zona amarilla), entre 10 cm e impacto (zona roja).

■ Luego de medir la distancia se la compara con el umbral que indica fuera de rango (50 cm).
■ Si la distancia es menor a ese valor está en zona verde: se enciende el led verde y emite el tono de 2000 c/s.
■ Si la distancia es menor a 30 cm y mayor a 10 cm está en zona amarilla: enciende el led amarillo y emite el tono de 2500 c/s.
■ Si la distancia es menor a 10 cm está en zona roja: enciende el led rojo y emite el tono de 3000 c/s.

Programa

Para esta determinación de rangos, es importante buscar en la hoja de especificaciones técnicas el rango de funcionamiento del sensor de ultrasonidos que disponemos. Para este artículo se usó uno que puede medir de 2 cm a 400 cm.

Artículos relacionados:

VL53L0X: Sensor de distancia que mide por la velocidad de la luz (Time-of-Fly)

Dando a los vehículos autónomos una “visión eléctrica” más aguda

Módulo de emisor piezoeléctrico pasivo KY-006 (Kit de sensores Keyes 6)

RCWL-0516: Módulo sensor de movimiento de microondas con radar Doppler