Às vezes, nossos projetos precisam de uma dose extra de segurança. Isso pode ocorrer em diversas aplicações, como mecanismos de travamento de portas, prevenção do uso inseguro ou não autorizado de máquinas ou, indo para algo mais específico, adereços para salas de escape. Neste artigo, vamos guiá-lo por uma montagem de atuador com teclado e mostrar como proteger com senha a operação do seu atuador linear.
Veja o que vamos utilizar:
- Arduino Uno.
- Teclado matricial 4x4.
- Módulo de relé de 2 canais (nas imagens é mostrado um de 4 canais, mas apenas 2 canais são necessários).
- Atuador PA-03-6-600.
- Fonte de alimentação PS-20-12.
- Buzzer (opcional).
Fiação do seu Atuador
Primeiro, vamos começar pela fiação. Para conseguir estender e retrair seu atuador, precisaremos usar ambos os canais do nosso módulo de relé de 2 canais. Assim, quando o Relé Um estiver ativo, a corrente fluirá em uma direção e, quando o Relé Dois estiver ativo, a corrente fluirá na direção oposta. Se nenhum ou ambos os relés estiverem ativos, nenhuma corrente fluirá para o atuador. Para isso, faremos as seguintes conexões.
Relés para o Atuador e a Fonte de Alimentação
- +12V em NC1 (terminal normalmente fechado no relé um) (fio branco).
- -12V em NO1 (terminal normalmente aberto no relé um) (fio preto).
- NC1 para NC2 (fio jumper azul).
- NO1 para NO2 (fio jumper verde).
- COMMON1 para o Atuador (fio marrom do atuador).
- COMMON2 para o Atuador (fio azul do atuador).
Arduino para o Teclado e o Módulo de Relé
- Conecte os pinos 1–8 do teclado aos pinos 2–9 do Arduino (nessa ordem).
- Pino 10 do Arduino em IN1 no módulo de relé.
- Pino 11 do Arduino em IN2 no módulo de relé.
- 5V do Arduino em VCC no módulo de relé.
- GND do Arduino em GND no módulo de relé.
- Ânodo do buzzer (perna mais longa) no pino 12 (opcional).
- Cátodo do buzzer (perna mais curta) em GND (opcional).
Programando seu Projeto
Agora que fizemos todas as conexões, estamos prontos para o código. O objetivo deste código é ler as entradas de um teclado, procurar a sequência correta de 5 dígitos e acionar nossos relés de acordo. Há também um código para um buzzer opcional que fornece feedback. Se não quiser usar o buzzer, basta não conectá-lo e deixar o código como está. Se precisar usar o pino do buzzer para outra coisa, exclua ou comente todo o código usado para as funções do buzzer ou de “beep”.
No código abaixo, você encontrará comentários em quase todas as linhas (texto cinza claro que segue “//”). Esses comentários descrevem o que está acontecendo no sketch e também as modificações que você pode fazer. A seguir, detalhamos algumas seções importantes para uma explicação mais completa.
Código de Configuração
No nosso código de configuração, definiremos os pinos do buzzer e dos relés como saídas. O buzzer iniciará em LOW e os relés iniciarão em HIGH. Isso fará com que todos fiquem inativos quando ligarmos o Arduino pela primeira vez. Também executaremos a função “retract()” uma vez para que o Arduino saiba o estado correto do atuador.
void setup() //runs once on startup
{
digitalWrite(buzzer, LOW);//deactivates buzzer
digitalWrite(relay1,HIGH);//deactivates relay1
digitalWrite(relay2,HIGH);//deactivates relay2
for(int i=10;i<14;i++)
{
pinMode(i,OUTPUT);//sets pins 10 - 13 as outputs
}
Serial.begin(9600);//Starts the serial monitor at 9600 baud rate (for debugging only)
retract();//retracts the actuator on startup if it is not already. comment this out if you do not want the actuator to retract on startup
Serial.println("READY");//lets us know the serial monitor is running
}
Código do Teclado
Neste sketch, usamos a biblioteca Keypad.h. Ela contém as funções que utilizamos para receber entradas do teclado. Para usá-la, precisamos criar uma matriz bidimensional para mapear os caracteres do teclado. Isso é feito definindo primeiro o número de linhas e o número de colunas do teclado. Em seguida, montamos nossa matriz com cada caractere do teclado. Nosso teclado tem quatro linhas, quatro colunas e oito pinos de saída. Há um pino para cada linha e um pino para cada coluna. Mostramos isso no código criando um array “rowPins” que contém as entradas digitais conectadas aos pinos de linha e um array “colPins” que contém as entradas digitais conectadas aos pinos de coluna. Quando pressionamos uma tecla, conectamos um dos pinos de linha a um dos pinos de coluna. Por exemplo, ao pressionar o botão 2, criamos um circuito fechado entre o pino de linha um e o pino de coluna dois.
char customKey; //characters input by pressing keypad
const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
char keys[ROWS][COLS] = { //layout your "keymap" here
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {2, 3, 4, 5}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {6, 7, 8, 9}; //connect to the column pinouts of the keypad
Keypad customKeypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS); //initialize an instance of class NewKeypad
Código da Senha
Neste exemplo de controle seguro de atuador linear, nossa senha tem 5 dígitos, portanto definimos “Passcode_Length” como “6”. Isso porque precisamos de um espaço extra para o caractere nulo. Se quiser alterar o tamanho da senha, basta trocar o 6 por um número que seja um a mais do que o comprimento desejado. Depois disso, altere o valor de “Passcode” para os caracteres que preferir (padrão “12345”).
O caractere associado a cada tecla pressionada será armazenado no array “Input”. Quando esse array tiver 5 caracteres, ele comparará os valores de “Input” e “Passcode” para verificar se a senha está correta. Se forem iguais, o código mandará o Arduino estender ou retrair o atuador (dependendo do estado atual do atuador). Se a senha estiver incorreta, o pino do buzzer ficará em nível alto três vezes rapidamente e depois voltará a baixo. Em ambos os casos, a função “clearInput()” será chamada em seguida para limpar o array Input e abrir espaço para uma nova entrada.
Código de Extensão e Retração
Há duas funções muito semelhantes neste código: “void extend()” e “void retract()”. Quando chamada, a void extend() colocará o Relé Um em nível baixo, ativando-o. Isso fechará um circuito e aplicará uma tensão positiva ao atuador. O relé permanecerá ativo pelo tempo definido em “const int extendTime” (padrão de 25.000 milissegundos). A função void retract() fará exatamente o mesmo, mas usará o relé dois para inverter a tensão em vez do relé um.
void extend()//extend the actuator
{
longBeep();
Serial.println("EXTENDING...");
digitalWrite(relay2,HIGH);//makes sure relay2 is not active
digitalWrite(relay1,LOW);//activates relay1
delay(extendTime);
digitalWrite(relay1,HIGH);//deactivates relay1
Serial.println("DONE EXTENDING");
extended = true; //tells the arduino that the actuator is extended
longBeep();
}
void retract()//extend the actuator
{
longBeep();
Serial.println("RETRACTING...");
digitalWrite(relay1,HIGH);//makes sure relay1 is not active
digitalWrite(relay2,LOW);//activates relay2
delay(retractTime);
digitalWrite(relay2,HIGH);//deactivates relay2
Serial.println("RETRACTING DONE");
extended = false; //tells the arduino that the actuator is retracted
longBeep();
}
Toques Finais
Depois de fazermos todas as conexões e enviarmos o código, teremos um sistema de controle de atuador protegido por senha em pleno funcionamento. Se tiver problemas na primeira configuração, experimente usar a ferramenta Monitor Serial no IDE do Arduino. Ela pode ajudar muito a identificar se os problemas são causados por código, fiação ou componentes defeituosos.
Esse código também pode ser modificado além de apenas trocar a senha. Considere substituir sua placa de relés por um shield MegaMoto para ter controle de velocidade ou usar um atuador com feedback de efeito Hall para controle de posição.
Esperamos que este artigo tenha sido útil! Se tiver alguma pergunta sobre este ou qualquer outro atuador linear controlado remotamente, ou quiser compartilhar seu projeto conosco, fique à vontade para nos ligar ou enviar um e-mail.