Continuamos a série de artigos sobre o uso dos recursos do kit Digital Lab NR05 para estudar a programação de microcontroladores usando o exemplo do Arduino e projetar dispositivos eletrônicos úteis.
Nosso material não pretende ser um projeto pronto, mas, como você verá, cumpre todas as funções básicas de um bloqueio de código e pode servir como uma boa ilustração dos recursos dos microcontroladores e do uso de plug-ins externos. O programa para o microcontrolador pode ser refeito a seu critério, adicionando ou alterando as funções do bloqueio e, ao mesmo tempo, aumentando o nível de seu conhecimento de programação.Usaremos, antes de tudo, o fato de que a placa de expansão, que faz parte do conjunto, possui uma tela de cristal líquido de duas linhas, além de 5 botões. Usamos esses elementos para criar um bloqueio de combinação.Vamos fazer os seguintes requisitos:1. Existem 5 botões para inserir o código que abre a fechadura;2. O botão mais à esquerda corresponde ao código 1, depois da esquerda para a direita - 2,3,4,5;3. O número de dígitos do código de entrada pode ser qualquer um (dentro de limites razoáveis) e simplesmente instalado no programa;4. O código discado é exibido com asteriscos;5. Se o código inserido coincidir com o exemplo, um impulso positivo da duração especificada no programa é fornecido ao atuador;6. Se o código for inserido incorretamente, uma mensagem de erro será exibida;7. Se você digitar parcialmente o código, depois de um tempo os valores discados serão redefinidos.8. Utilizamos a tela, o LED RGB e o emissor de som incluído no kit para exibir informações fáceis de usar.9. Abriremos uma trava eletromecânica real alimentada por 12 volts.Agora, escolhemos o dispositivo que aplicará a tensão de abertura na trava. Essa tensão, de acordo com o passaporte da trava eletromecânica, que abriremos, é de 12 volts a uma corrente de cerca de 1 ampere. A placa de expansão do kit NR05 não pode trabalhar com essas tensões e correntes; portanto, é necessário um módulo de comutação adicional. Esses módulos podem ser relés MP515 oferecidos pelo Master Kit ou unidades de relé MP2211 , MP4411dependendo se queremos controlar não apenas a trava, mas também outros dispositivos, por exemplo, acendem a luz quando a porta é aberta. Todos esses dispositivos são compatíveis com os níveis de sinal de controle do Arduino. No nosso caso particular, usamos o MP2211 - um módulo com dois relés.Diante do exposto, desenharemos um diagrama de conexão dos dispositivos utilizados:
Se você observar atentamente a marcação da placa de expansão, veremos que o canal verde do LED GREEN RGB e a saída do relé CH3 estão conectados a um pino do D9 Arduino Nano. Nesse caso, isso é permitido, uma vez que a entrada do circuito de controle do relé possui uma resistência de entrada suficientemente alta e o pino D9 é usado apenas como uma saída digital. Em geral, você deve verificar se os pinos da placa que você está usando estão conectados ao mesmo pino do Arduino e evitar essa situação.A trava consome bastante corrente durante a operação, portanto, nós a alimentamos e o circuito de controle separadamente.Aqui está um esboço trabalhando no Arduino, um 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;
}
//
A lista de rascunhos é fornecida com comentários detalhados para ajudar você a entender o programa.No entanto, chamamos sua atenção para algumas de suas características.Como já escrevemos, na placa de expansão é usado um esquema de conexão de botão que usa apenas um pino do Arduino. Esse esquema salva as saídas do microprocessador, mas não permite processar a pressão simultânea de vários botões ao mesmo tempo, mas, no nosso caso, isso não é necessário. Observe a função get_key no final do esboço. Se nenhum botão for pressionado, a função retornará 0, se pressionado, o número do botão pressionado. Observetambém a implementação da comparação de duas matrizes: referência e códigos digitados:int compareResult = 1;for (int i = 0; i <codeLength; i ++)if (codeOrigin [i]! = codePressed [i])compareResult = 0; // se pelo menos um par de elementos não for igual Aquestão do algoritmo para essa comparação é frequentemente discutida nos fóruns de programação, mas sempre que se trata de uma comparação elementar, usada no nosso caso. A variável compareResult permanece igual a 1 se os elementos de matrizes com o mesmo índice forem iguais e se tornará igual a 0 se pelo menos um par de elementos não corresponder.Para exibir caracteres cirílicos, é usada a biblioteca LiquidCrystalRus, desenvolvida por Ilya Danilov. Para que a biblioteca funcione corretamente, deve haver três linhas no título do nosso esboço:#include <LiquidCrystalRus.h>#include <LineDriver.h>#include <LiquidCrystalExt.h>E a inicialização da tela deve ficar assim:LiquidCrystalRus lcd (A1, A2, A3, 2, 4, 7);O comprimento do código de entrada é especificado pela constante codeLength predefinida, por exemplo, para um código de seis cliques#define codeLength 6Uma matriz de valores de referência para um código de 6 cliques é especificada pela seguinte linha:const int codeOrigin [codeLength] = {1, 2, 3, 4, 5, 3} ;O número de valores entre chaves deve ser igual a codeLength. Se houver mais valores, o compilador lançará um erro; se houver menos, não haverá erro, mas valores aleatórios serão usados como elementos ausentes, o que não permitirá digitar o código que abrirá o bloqueio.A cada 5 segundos, o programa redefine os elementos do código digitado. Se o botão foi pressionado, a hora do pressionamento é lembrada e a contagem regressiva do intervalo de cinco segundos começa novamente. Isso é implementado usando as funções internas millis (), que retornam o número de milissegundos que passaram desde o início do esboço e as variáveis oldTime e currentTime.Aqui está um pequeno vídeo demonstrando a operação do bloqueio de código:Para programadores eletrônicos curiosos e curiosos, você pode lançar mais algumas idéias para a finalização automática do esboço e a inclusão de módulos no circuito que expandem as capacidades do castelo. Por exemplo, insira um código mestre no programa, com a ajuda da qual a trava é colocada no modo de programação e lembra os botões pressionados como um código de referência, para não alterar esse código no esboço. A programação de um novo código termina se o intervalo entre cliques exceder um determinado tempo.Ou, com base no material sobre a interação do Arduino com um smartphone via Bluetooth, faça um bloqueio que é aberto com um código enviado por esse mesmo smartphone.Você também pode simplesmente entrar no canal de controle sem fio em nosso dispositivo. Para fazer isso, basta usar dois módulos: o transmissor-transmissor MP910 e um receptor de canal único com saída a relé MP911 , operando a uma frequência de 433 MHz. Os contatos do relé do módulo MP2211 são conectados em paralelo com o botão no controle remoto, e o relé do módulo receptor é conectado à trava. A distância de controle pode ser de até 100 M.Estude Arduino, estude microcontroladores e sua programação - e você pode criar muitos dispositivos eletrônicos inteligentes e úteis!