Por Andreas Wolter "Detector de Santa Claus" después de haber agregado dos transceptores nRF24L01 para recibir las señales del sensor en otra habitación, los dos módulos estaban en mi mesa, listos para un nuevo proyecto. ¿No he querido durante mucho tiempo cambiar diferentes circuitos de luz en mi sistema de maquetas de ferrocarril con relés? El microcontrolador con el receptor de radio y los relés ocultos en algún lugar debajo de la placa, el transmisor a mano junto a los paneles de control.
En la primera opción utilizo interruptores, en la segunda opción botones o un panel táctil capacitivo para encender y apagar los relés.
Hardware utilizado
| Numero | Componentes de hardware |
|---|---|
| 1 | Microcontrolador con ATmega 328 |
| 1 | relés de 4 u 8 velocidades |
| 2 | Transmisor-receptor de 2,4 MHz nRF24L01 (opcional Placa De Adaptador De) |
| 1 | Microcontrolador Nano V3.0 |
| 1 | "Mouse piano" (interruptor dip) o 4-8 interruptores |
| alternativa | 4-8 Botones |
| alternativa | Módulo de Sensor Capacitivo Táctil Digital de 16 Canales TTP229 |
| Cables de media tabla de cortar el pan y puente |
Consideraciones preliminares para la transmisión de señales
Para una transmisión de datos segura, tiene sentido seleccionar un código único para los estados de conmutación deseados. A un código base elegido arbitrariamente de 4000, agrego la potencia de dos de los relés deseados en cada caso. Como siempre con la programación, el conteo comienza en 0 y termina en 3 para cuatro relés o en 7 para ocho relés.
Ejemplo: Los relés 0, 2 y 7 deben conmutarse, por lo que 4000 + 2 alto 0 + 2 alto 2 + 2 alto 7 dan como resultado un código de 4000 + 1 + 4 + 128 = 4133. Cuando el segundo relé se apaga, el código cambia a 4129. Una pequeña mesa en la valencia de los relés (= potencias de dos):
|
n |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
2 n alto |
1 |
2 |
4 |
8 |
16 |
32 |
64 |
128 |
Sin embargo, en nuestro circuito usamos lógica negativa, es decir, debido a las resistencias pull-up internas (ver más abajo), el estado de apagado es 1, cuando se enciende, conectamos el pin a GND y el estado se convierte en 0. En este caso, restamos el valor respectivo de 4015 (para cuatro interruptores, de lo contrario 4255), por lo que el código 4015 significa: los 4 interruptores apagados, el código 4000 significa todos los interruptores encendidos.
Para evaluar el código en el receptor, primero restamos los 4000 seleccionados arbitrariamente; el valor restante está entre 0 (todo ACTIVADO) y 15 (cuatro desactivados) o 255 (ocho desactivados). Con mi relé de 4 vías, la lógica negativa me ayuda, porque los relés individuales se activan cuando la entrada respectiva está conectada a GND. Por favor, preste atención a qué tipo de relé desea usar y en qué condiciones está energizado. El tema de la "lógica negativa" lo recojo a continuación abre de nuevo.
Para el procedimiento posterior, un pequeño bucle for con la función ayudará bitRead().
al principio del sketch:
int BitArray[4]; // resp. 8 por 8 relés
en la función loop() :
para (i = 0; i < 4; i++) {
BitArray[i] = bitRead(var, i); // Variable var significa el código corregido
Al final, BitArray [i] muestra el estado de conmutación 0 o 1 para cada relé.
Integración de los transceptores en ambos bocetos
En primer lugar, las bibliotecas de programas necesarias se integran al principio del boceto:
/ * Biblioteca: TMRh20 / RF24, https://github.com/tmrh20/RF24/
*/
RF24 Radio(9, 10); // CE, CSN,MOSI = 11, MISO = 12, SCK=13
const byte dirección[6] = "Code8"; // dirección de los transceptores libremente seleccionable
La función void setup() se inicializa:
Radio.comenzar();
Radio.Tubo de escritura abierta(dirección);
Radio.setPALevel(RF24_PA_MIN);
Radio.stopListening(); // en el transmisor
o.:
Radio.Aviso de inicio(); // destinatario
En el croquis del remitente defino una función sendcode:
anular código de envío() {
Radio.escribir(&codificar, tamaño de(codificar));
retraso(100); // poco retraso para presionar el siguiente botón
}
Para el receptor, la función void loop() comienza con
si (Radio.disponible()) {
Radio.Leer(&codificar, tamaño de(codificar));
La parte más fácil es básicamente la consulta de los conmutadores: establecer números de pin, establecerlos como entradas en la configuración y consultar los estados en el bucle (bucle). Para evitar resistencias innecesarias, opto por las resistencias pull-up incorporadas; esto significa lógica negativa (ver arriba), el pasador se cambia a GND. Y debido a la gran cantidad de conmutadores, opto por matrices con los números de pines y los estados de conmutación.
El circuito para el transmisor con cuatro interruptores
En lugar de 4 u 8 interruptores individuales, uso un "mouse piano". Qué es esto, preguntan los más jóvenes. Son ocho interruptores en miniatura seguidos. Ampliamente utilizado en las placas base de la computadora de la década de 1990 para determinar la configuración respectiva de la PC.
Imagen y esquema
El boceto para el transmisor con cuatro interruptores (Descargar):
/*
* Comunicación inalámbrica Arduino
* Código de transmisor para 4 relés
* Biblioteca: TMRh20 / RF24, https://github.com/tmrh20/RF24/
*/
RF24 Radio(9, 10); // CE, CSN
const byte dirección[6] = "Code8";
int codificar=4000;
int Columnas de entrada[4]={2,3,4,5};
anular configuración() {
Serie.comenzar(9600);
para (int i=0; i <= 3; i++){
Modo PIN(Columnas de entrada[i],INPUT_PULLUP);
}
Radio.comenzar();
Radio.Tubo de escritura abierta(dirección);
Radio.setPALevel(RF24_PA_MIN);
Radio.stopListening();
} // configuración final
anular código de envío() {
Radio.escribir(&codificar, tamaño de(codificar));
retraso(100); // poco retraso para presionar el siguiente botón
} // fin de código de envío
anular bucle() {
codificar = 4000;
int n = 1;
para (int i=0; i <= 3; i++){
int digRead = Lectura digital(Columnas de entrada[i]);
Serie.imprimir("i=");
Serie.imprimir(i);
Serie.imprimir("digRead=");
Serie.println(digRead);
codificar = codificar + n * digRead;
n = n*2;
}
Serie.imprimir(" Codificar =");
Serie.println(codificar);
código de envío();
} // bucle final
El circuito para el receptor con cuatro relés
Imagen y esquema
El boceto para el receptor con cuatro relés (Descargar):
/*
* Comunicación inalámbrica Arduino
* Código de receptor para 4 relés
*
* Biblioteca: TMRh20 / RF24, https://github.com/tmrh20/RF24/
*/
RF24 Radio(9, 10); // CE, CSN,MOSI = 11, MISO = 12, SCK=13
const byte dirección[6] = "Code8";
int codificar = 4000;
int Columnas de salida[4]={2,3,4,5}; // resp. 8 por 8 relés
int BitArray[4]; // resp. 8 por 8 relés
int var = 0;
anular configuración() {
Serie.comenzar(9600);
para (int i=0; i <= 3; i++){
Modo PIN(Columnas de salida[i],SALIDA);
}
Radio.comenzar();
Radio.Tubo de lectura abierta(0, dirección);
Radio.setPALevel(RF24_PA_MIN);
Radio.Aviso de inicio();
} // configuración del vacío final
anular bucle() {
si (Radio.disponible()) {
Radio.Leer(&codificar, tamaño de(codificar));
Serie.println(codificar);
si (codificar>=4000 &&codificar<4256) {
Serie.imprimir("El código es ");
Serie.println(codificar-4000);
var = codificar-4000;
Serie.println(var,SER);
int i = 0;
para (i = 0; i < 4; i++) {
BitArray[i] = bitRead(var, i);
Serie.imprimir("Interruptor ");
Serie.imprimir(i+1);
Serie.imprimir("deberá ");
Serie.println(BitArray[i]);
Escritura digital(Columnas de salida[i],BitArray[i]);
}
}
}
} //final void loop
Y ahora todo de nuevo con botones o el panel táctil capacitivo:
No todo el mundo tiene un piano de ratón o un interruptor. Pero los botones (botón) se pueden encontrar en todos los fabricantes o técnicos de electrónica aficionados. Sin embargo, al usar botones, necesitamos ajustar las parodias para encender o apagar un relé con solo tocar un botón en cada caso. (¿Quién quiere mantener pulsado el botón todo el tiempo?).
Necesitamos tres variables para cada botón (cada relé al final del enlace de radio):
- el estado que queremos enviar
- el estado anterior
- el estado actual de nuestro pulsador
Para todas las señales de entrada, volvemos a utilizar matrices:
int Estacas[4]={0,0,0,0};
int Pines de Estado de Carga[4]={0,0,0,0};
int Tipo de vástago: vertical[4]={0,0,0,0};
En el bucle void(), consultamos todos los botones uno por uno en un bucle for y los comparamos con el estado anterior. Si estos son desiguales y el botón vuelve a estar BAJO, el estado enviado se invierte. Finalmente, la variable se actualiza para el estado anterior.
para (i=0; i <= 3; i++){
Tipo de vástago: vertical[i] = Lectura digital(Columnas de entrada[i]);
}
retraso(100); // evitar rebotar
para (i=0; i <= 3; i++){
si (Tipo de vástago: vertical[i] != Pines de Estado de Carga[i]) {
si (Tipo de vástago: vertical[i] == BAJO) {
Estacas[i] = !Estacas[i];
}
Pines de Estado de Carga[i] = Tipo de vástago: vertical[i];
}
Aquí está el boceto para Descargar.
Si no le gusta el hecho de que la primera vez que enciende todos los relés están encendidos (recordamos: "lógica negativa"), puede hacer un pequeño cambio en el boceto del receptor:
Cambiamos la línea 35 a:
var = 15 - (codificar-4000); // para 8 relés 255 - ()
Esto también se aplica a mi relé de 4 vías, en el que las entradas deben estar "conectadas a tierra" para encenderse.
"Tocar" en lugar de"empujar":
Hay una variedad de botones que son mecánica y eléctricamente casi indestructibles: sensores táctiles que funcionan según el principio de cambio de capacitancia.
En lo siguiente utilizo el Módulo de Sensor Capacitivo Táctil Digital de 16 Canales TTP229, que funciona de dos maneras diferentes: 1. Hay ocho salidas, que se cambian a ALTA cuando se tocan los botones del 1 al 8. 2. Y hay una salida en serie con dos líneas SCL y SDO.
Notas sobre 1. Tenemos que tener en cuenta la "lógica positiva" (alta activa) en el circuito y en el boceto (ver más abajo). Y definitivamente podemos usar un máximo de ocho touchpads.
Comentarios en 2. A pesar de la similitud de nombres, las dos líneas no son expresamente una interfaz I2C. Por lo tanto, la biblioteca TTP229 de Alexander Kiryanenko, que se muestra en el administrador de bibliotecas del IDE Arduino, puede ser ni ser usado. Hay una biblioteca adecuada en la página del producto en Descargas.
Observaciones generales: Se pueden configurar varias opciones con puentes en otros contactos que no están provistos de pines. Los valores predeterminados de "toque único" y la limitación a los primeros ocho touchpads son correctos para nuestro proyecto. La fuente de alimentación no es crítica para todos los microcontroladores, son posibles tanto 3,3 voltios como 5V. Más información sobre esto a continuación.
Si, como yo, solo desea cambiar un máximo de cuatro relés, le recomiendo usar las salidas digitales OUT1 a OUT4, es decir, 2 líneas para la fuente de alimentación y cuatro líneas para las entradas digitales en el microcontrolador, sin puentes y sin biblioteca de programas.
Además de la conexión con OUT1 a OUT4, tenemos que cambiar las llamadas resistencias desplegables entre las entradas y GND para que siempre tengamos un estado definido. Cuando se toca el panel táctil respectivo, la entrada es ALTA, después de soltarla vuelve a ser BAJA.
En el boceto de los botones, solo se deben cambiar dos líneas:
En la línea 21, el modo PIN se establece en lugar de INPUT_PULLUP de la siguiente manera:
Modo PIN(Columnas de entrada[i],ENTRADA);
Y en la línea 43 se pregunta si la entrada se cambia a ALTA:
si (Tipo de vástago: vertical[i] == ALTO) {
Personalmente, encuentro que la "lógica positiva" es más fácil de entender. Desafortunadamente, los Arduinos solo conocen OUTPUT, INPUT y INPUT_PULLUP como modo PIN (con resistencias PULLUP internas). Por lo tanto, se requieren resistencias desplegables externas para esto como se describió anteriormente. Pero también está el microcontrolador ESP32, que entiende el modo PIN INPUT_PULLDOWN (es decir, tiene resistencias pulldown internas).
Sin embargo, el fabricante del módulo también ha incorporado la posibilidad de lógica negativa, por lo que OUT1 a OUT8 obtienen potencial GND cuando se tocan. Sin embargo, para esto necesitamos agarrar el soldador y soldar las tiras de pasadores adicionales (no incluidas). Mientras estamos en ello: aquí está la descripción de las opciones más importantes:
|
TP0 |
0 |
8 pines de salida-CMOS active de baja salida |
Los puentes están listos |
|
TP0 |
1 |
8 pines de salida-CMOS active de alto rendimiento |
Predeterminado |
|
TP2 |
0 |
modo de 16 canales (16 teclas de entrada) |
Juego de puente, solo 2 hilos |
|
TP2 |
1 |
modo de 8 canales (8 teclas de entrada) |
Por defecto, 2 cables o SALIDA |
|
TP3 y TP4 |
0, 0 |
Todas las teclas múltiples |
Ambos puentes están configurados |
|
TP3 y TP4 |
1, 1 |
Todas las llaves individuales |
Predeterminado |
Por lo tanto: Si desea tener la lógica negativa (BAJA activa) en los pines de SALIDA digitales, debe configurar el puente en TP0, pero no un puente en TP2. Los cambios en la configuración requieren un reinicio del módulo.
A pesar de que he probado varias opciones: los valores predeterminados (todas las conexiones abiertas, no se requiere soldadura) son adecuados para nuestro proyecto con cuatro u ocho relés.
Ahora será aún más difícil. Pero vale la pena! Solo dos líneas de datos (más la fuente de alimentación) para ocho o incluso dieciséis touchpads. Como se describió anteriormente, es ni para crear una interfaz I2C. Por lo tanto, podemos usar pines digitales normales para SCL y SDO. Pero la lectura de los datos requiere cierta biblioteca.
Para ello, descargamos desde la página del producto de la Módulo de Sensor Capacitivo Táctil Digital de 16 Canales TTP229 en la columna "Descargas y Enlaces importantes", Bibliotecas de Arduino abajo.
El archivo es obligatorio TTP229.zip con el siguiente contenido:
Este archivo zip se coloca en la subcarpeta \Arduino\libraries y luego en el menú Incluye Sketch / Biblioteca/.Añadir una biblioteca ZIP… involucrados. Esto también hace que dos bocetos de ejemplo estén disponibles: Calculadora y KeyToSerial. El primer boceto muestra el "modo de teclas múltiples", es decir, la posibilidad de presionar varios paneles táctiles al mismo tiempo, el segundo boceto muestra el modo de tecla única, es decir, solo un panel táctil a la vez. Ambos bocetos utilizan la conexión de 2 cables, es decir, SCL y SDO.
De vuelta a nuestro proyecto con control remoto por radio de cuatro u ocho relés, ahora conectamos SCL con pin D2 y SDO con pin D3 (seleccionable libremente).
En mi sketch (Descargar) elegí la rama switch - case porque había recibido resultados absurdos con la función exponencial pow() debido a diferentes tipos de datos y errores de redondeo. El único obstáculo: Los teclados tienen las designaciones 1 a 8, pero los valores son 2 alto 0 a 2 alto 7, por lo que siempre uno más bajo que el número en el teclado. El dibujo en el lado del receptor permanece sin cambios, a menos que desee cambiar ocho relés.
Eso es. En realidad no es difícil, si no tuviéramos que torturarnos con resistencias lógicas negativas (bajas activas) o desplegables. Diviértete recreando.
1 comentario
TOMMERAY
Merci, du matériel proposé avec explications en français et le sketch qui va avec. Un pas en avant, c’est parfait.