Continuamos la serie de artículos sobre el uso de las capacidades del kit Digital Lab NR05 para estudiar la programación de microcontroladores utilizando el ejemplo de Arduino y el diseño de dispositivos electrónicos útiles.
Nuestro material no pretende ser un diseño terminado, pero, como verá, cumple con todas las funciones básicas de un código de bloqueo y puede servir como una buena ilustración de las capacidades de los microcontroladores y el uso de complementos externos. El programa para el microcontrolador puede rehacerse a su discreción, agregando o cambiando las funciones de la cerradura, y al mismo tiempo aumentando el nivel de su conocimiento de programación.Utilizaremos, en primer lugar, el hecho de que la placa de expansión, que forma parte del conjunto, tiene una pantalla de cristal líquido de dos líneas, así como 5 botones. Usamos estos elementos para construir una cerradura de combinación.Hagamos los siguientes requisitos:1. Hay 5 botones para ingresar el código que abre el bloqueo;2. El botón de la izquierda corresponde al código 1, luego de izquierda a derecha - 2,3,4,5;3. El número de dígitos del código de entrada puede ser cualquiera (dentro de límites razonables) y simplemente instalarse en el programa;4. El código marcado se muestra con asteriscos;5. Si el código ingresado coincide con el ejemplar, se suministra un impulso positivo de la duración especificada en el programa al actuador;6. Si el código se ingresa incorrectamente, aparece un mensaje de error;7. Si escribe parcialmente el código, luego de un tiempo se restablecen los valores marcados.8. Utilizamos la pantalla, el LED RGB y el emisor de sonido incluido en el kit para mostrar información fácil de usar.9. Abriremos una cerradura electromecánica real alimentada por 12 voltios.Ahora recogemos el dispositivo que aplicará el voltaje de apertura a la cerradura. Este voltaje, de acuerdo con el pasaporte de la cerradura electromecánica, que abriremos, es de 12 voltios a una corriente de aproximadamente 1 amperio. La tarjeta de expansión del kit NR05 no puede funcionar con tales voltajes y corrientes, por lo que se necesita un módulo de conmutación adicional. Dichos módulos pueden ser relés MP515 ofrecidos por Master Kit o unidades de relé MP2211 , MP4411dependiendo de si queremos controlar no solo la cerradura, sino también otros dispositivos, por ejemplo, encender la luz cuando se abre la puerta. Todos estos dispositivos son compatibles con los niveles de señal de control de Arduino. En nuestro caso particular, utilizamos MP2211, un módulo con dos relés.Dado lo anterior, dibujaremos un diagrama de conexión de los dispositivos utilizados:
Si observa de cerca la marca de la placa de expansión, veremos que el canal verde del LED VERDE RGB y la salida al relé CH3 están conectados a un pin del D9 Arduino Nano. En este caso, esto es permisible, ya que la entrada del circuito de control del relé tiene una resistencia de entrada suficientemente alta, y el pin D9 se usa solo como salida digital. En general, debe verificar si los pines de la placa que está utilizando están conectados al mismo pin Arduino y evitar esta situación.El bloqueo consume mucha corriente durante el funcionamiento, por lo que lo alimentamos y el circuito de control por separado.Aquí hay un boceto trabajando en Arduino, un spoiler// RGB-
// NR05
//-------------------------------------------------------------------
// LiquidCrystalRus
#include <LiquidCrystalRus.h>
#include <LineDriver.h>
#include <LiquidCrystalExt.h>
// RGB-
#define red 5
#define blue 6
#define green 9
#define beep 12
// ,
#define NUM_KEYS 5
// ( )
int adcKeyVal[NUM_KEYS] = {30, 150, 360, 535, 760};
///////////////////////////////////////////////////////////
// ,
#define codeLength 6
// , , . codeLength
const int codeOrigin[codeLength] = {1, 2, 3, 4, 5, 3};
// ,
const int unlockTime = 400;
///////////////////////////////////////////////////////////
//
int codePressed[codeLength];
// ( )
int pressCount;
//
unsigned long oldTime;
unsigned long currentTime;
const int timeout = 5; // , .
//-----------------------------------------------------------------------
// , RS,EN,DB4,DB5,DB6,DB7
LiquidCrystalRus lcd(A1, A2, A3, 2, 4, 7);
//-----------------------------------------------------------------------
// 1 Arduino
void setup()
{
// LCD: 16 2
lcd.begin(16, 2);
// ()
// « »
lcd.print(« »);
//
lcd.setCursor(0,1);
lcd.print(«t.: „);
lcd.print(unlockTime);
lcd.print(“ »);
// 2000 = 2
delay(2000);
//
lcd.clear();
//
pressCount = 0;
// « » RGB-
pinMode(red, OUTPUT);
pinMode(blue, OUTPUT);
pinMode(green, OUTPUT);
pinMode(beep, OUTPUT);
}
//-----------------------------------------------------------------------
// setup .
void loop() {
// ( ),
currentTime = millis();
// ,
if (currentTime — oldTime <= timeout*1000){
// key
int key;
// , get_key
key = get_key();
lcd.setCursor(0, 0);
lcd.print(« :»);
//
digitalWrite(blue, HIGH);
if (key > 0){ //
codePressed[pressCount] = key; //
// (50 )
digitalWrite(beep, HIGH);
delay(50);
digitalWrite(beep, LOW);
// ,
lcd.setCursor(pressCount, 1);
lcd.print('*');
digitalWrite(blue, LOW);
delay(200);
digitalWrite(blue, HIGH);
pressCount++; //
//
oldTime = currentTime;
}
}
// ,
else{
pressCount = 0;
lcd.clear();
oldTime = currentTime;
}
// , : codeOrigin codePressed
if (pressCount == codeLength){
int compareResult = 1;
for (int i = 0; i < codeLength; i++)
if (codeOrigin[i] != codePressed[i])
compareResult = 0; //
//
if (compareResult == 1){ //
digitalWrite(blue, LOW);
digitalWrite(green, HIGH);
lcd.setCursor(0, 0);
lcd.print(« „);
delay(unlockTime);
digitalWrite(green, LOW);
pressCount = 0;
delay(1000);
lcd.clear();
digitalWrite(blue, HIGH);
}
//
else {
lcd.setCursor(0, 1);
lcd.print(“ »);
digitalWrite(blue, LOW);
digitalWrite(red, HIGH);
digitalWrite(beep, HIGH);
delay(2000);
pressCount = 0;
lcd.clear();
digitalWrite(beep, LOW);
digitalWrite(blue, HIGH);
digitalWrite(red, LOW);
}
}
}
//-----------------------------------------------------------------------
//
// ,
// ,
int get_key()
{
int input = analogRead(A6);
int k;
for(k = 0; k < NUM_KEYS; k++)
if(input < adcKeyVal[k])
return k + 1;
return 0;
}
//
La lista de bocetos se proporciona con comentarios detallados para ayudarlo a comprender el programa.Sin embargo, llamamos su atención sobre algunas de sus características.Como ya escribimos, en la placa de expansión se usa un esquema de conexión de botón que usa solo un pin Arduino. Tal esquema guarda las salidas del microprocesador, pero no permite procesar la presión simultánea de varios botones al mismo tiempo, pero en nuestro caso esto no es necesario. Observe la función get_key al final del boceto. Si no se presiona ningún botón, la función devuelve 0, si se presiona, entonces el número del botón presionado.Observe también la implementación de comparar dos matrices: códigos de referencia y escritos:int compareResult = 1;for (int i = 0; i <codeLength; i ++)if (codeOrigin [i]! = codePressed [i])compareResult = 0; // si al menos un par de elementos no es igual Lacuestión del algoritmo para tal comparación a menudo se discute en foros de programación, pero cada vez se reduce a una comparación por elementos, que se utiliza en nuestro caso. La variable compareResult permanece igual a 1 si los elementos de las matrices con el mismo índice son iguales, y se vuelve igual a 0 si al menos un par de elementos no coincide.Para mostrar los caracteres cirílicos, se utiliza la biblioteca LiquidCrystalRus, desarrollada por Ilya Danilov. Para que la biblioteca funcione correctamente, debe haber tres líneas en el título de nuestro boceto:#include <LiquidCrystalRus.h>#include <LineDriver.h>#include <LiquidCrystalExt.h>Y la inicialización de la pantalla debería verse así:LiquidCrystalRus lcd (A1, A2, A3, 2, 4, 7);La longitud del código de entrada se especifica mediante la constante codeLength predefinida, por ejemplo, para un código de seis clics#define codeLength 6La siguiente línea especifica una matriz de valores de referencia para un código de 6 clics:const int codeOrigin [codeLength] = {1, 2, 3, 4, 5, 3} ;El número de valores entre llaves debe ser igual a codeLength. Si hay más valores, el compilador arrojará un error; si hay menos, no habrá error, pero se usarán valores aleatorios como elementos faltantes, lo que no permitirá escribir código que abrirá el bloqueo.Cada 5 segundos, el programa restablece los elementos del código escrito. Si se presionó el botón, se recuerda el momento de presionar, y la cuenta regresiva del intervalo de cinco segundos comienza nuevamente. Esto se implementa utilizando las funciones integradas millis (), que devuelve el número de milisegundos que han pasado desde el inicio del boceto, y las variables oldTime y currentTime.Aquí hay un breve video que demuestra el funcionamiento del código de bloqueo:Para programadores electrónicos curiosos e inquisitivos, puede lanzar algunas ideas más para la auto-finalización del boceto y la inclusión de módulos en el circuito que amplían las capacidades del castillo. Por ejemplo, ingrese un código maestro en el programa, con la ayuda de la cual el bloqueo se pone en modo de programación y recuerda los botones presionados como un código de referencia, para no cambiar este código en el boceto. La programación de un nuevo código finaliza si el intervalo entre clics excede un cierto tiempo.O, según el material sobre la interacción de Arduino con un teléfono inteligente a través de Bluetooth, haga un bloqueo que se abra con un código enviado por este mismo teléfono inteligente.También puede simplemente ingresar el canal de control inalámbrico en nuestro dispositivo. Para hacer esto, es suficiente usar dos módulos: el transmisor-transmisor MP910 y un receptor de un solo canal con salida de relé MP911 , que opera a una frecuencia de 433 MHz. Los contactos de relé del módulo MP2211 están conectados en paralelo con el botón del control remoto, y el relé del módulo receptor está conectado a la cerradura. La distancia de control puede ser de hasta 100 m.Estudie Arduino, estudie microcontroladores y su programación, ¡y puede crear muchos dispositivos electrónicos inteligentes y útiles!