sexta-feira, 9 de março de 2012

Arduino - Sistema de Segurança, Controle de Acesso

Arduino by my Self



Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);




Este projeto têm como objetivo, mostrar um uso prático do Arduino.

Um sistema de segurança para fazer o controle de acesso, por exemplo, da entrada de pessoas a um determinado ambiente seguro.

O sistema consta de um teclado para a entrada de uma senha, e um display LCD para visualizar mensagens.

A simulação é feita com LEDs, porém facilmente implementado para relés ou solenóides.

Como funciona:

Ao iniciar o sistema, um LED vermelho indica que o sistema está pronto, e neste caso não adianta digitar números no teclado, pois os mesmos não será processados; a não ser a tecla "#", que indicará ao sistema que alguém irá digitar uma senha.
Ao digitar "#"o sistema libera o teclado para a entrada da senha, e um LED amarelo sinaliza esta funcionalidade, bem como, será mostrado uma mensagem no display informar ao usuário que é necessário digitar a senha.
Digitando números no teclado (para cada um será emitido uma sinalização acústica), o sistema processará os dados.  
Se a quantidade de números digitar for igual a 4 e corresponder exatamente a senha do sistema, então será habilitato o relé ou o solenóide de acionamento (indicado por um LED verde, que irá piscar por cerca de 5 segundos, e o sistema estará liberado; durante esse período um som será emitido para sinalização; uma mensagem será mostrada no display, para informar ao usuário que o acesso foi liberado).
Se a quantidade de números digitados for 4 e não corresponder a senha esperado para o sistema, então o sistema não será liberado e voltará ao estado inicial.  O mesmo acontece se for pressionado a tecla "#" novamente.

O HARDWARE:
1 x Arduino UNO
1 x Teclado numérico 3x4
1 x Display LCD 2x16 I2C
1 x Buzzer
1 x Breadboard
4 x Resistores de 220O 1/8W
1 x LED verde 3mm
1 x LED Amarelo 3mm
1 x LED Vermelho 3mm
Fios e cabos para conexões

O CIRCUITO:
Utilize a breadboard para fazer as ligações:

Mini BreadBoard
BreadBoard


Para cada LED associar um resistor de 220O em série conectado ao terminal Anodo e o terminal catodo ligado diretamente ao negativo da alimentação. O outro terminal do resistor vai ligado ao Arduino, conforme abaixo:
Para o LED verde, terminal do resistor ligado ao pino 10  
Para o LED amarelo, terminal do resistor ligado ao pino 11
Para o LED vermelho, terminal do resistor ligado ao pino 12

Para o Buzzer, associar um resistor de 220O ao teminal positivo, sendo o terminal negativo do mesmo, ligado ao negativo da alimentação.  O outro terminal do resistor deve ser ligado ao pino 9 do Arduino.
Tipos variados de Buzzers
Buzzer soldável em placa


O teclado deve ser ligado da seguinte maneira:
Linha 1, ligada ao pino 5 do Arduino
Linha 2, ligada ao pino 4 do Arduino
Linha 3, ligada ao pino 3 do Arduino
Linha 4, ligada ao pino 2 do Arduino
Coluna 1, ligada ao pino 6 do Arduino
Coluna 2, ligada ao pino 7 do Arduino
Coluna 3, ligada ao pino 8 do Arduino

Detalhe da conexão flexível linhas x colunas
Teclado 4x3 flexível


Display I2C
Ligar o Vcc do dispositivo ao positivo da alimentação
Ligar o GND do dispositivo ao negativo da alimentação
Ligar o SDA do dispositivo ao pino A4 (analógico 4) do Arduino
Ligar o SCL do dispositivo ao pino A5 (analógico 5) do Arduino

Detalhe do adaptador I2C





Display I2C com BackLight azul e caracteres brancos




Diagrama:
Diagrama em fritzing
O Display LCD utilizado é um display I2C.


O SOFTWARE:
Abaixo o Software utilizado, com todos os comentários necessários (veja também o vídeo).

Este projeto foi baseado no projeto do Marcelo Rocha

Algumas modificações foram feitas para adequação somente.
Procurei deixar bem explicado, para que outras pessoas possam reproduzir com sucesso o experimento.

A versão 2 é ainda básica, somente para os primeiros passos, mais adiante versões mais completas.
/*
#################################################################################
#   Arquivo:            Tranca_Eletronica_v2.pde                                             
#       Micro-processador:  Arduino UNO         
#   Linguagem:    Wiring / C /Processing /Fritzing / Arduino IDE          
#
# Objetivo:           Tranca Eletrônica para controlede acesso
#  
# Funcionamento:    Ao pressionar #, libera para ser digitado a senha;
#                           se a senha estiver errada, volta ao estado inicial;
#                           Se a senha estiver correta, libera a porta;
#                           Simulação através de LEDs, porém adaptável a relés e travas
#                           Tons audíveis para orientação
#                           Display com as mensagens
#
#   Autor:              Marcelo Moraes 
#   Data:               20/02/12
#   Local:              Sorocaba - SP
#
#################################################################################
  Este exemplo é um código de domínio público.
 */
//Bibliotecas 
#include <Wire.h>
#include <LiquidCrystal_I2C.h>        //Esta biblioteca tem 2 versões uma está apropriada para o IDEv1.0
#include <Keypad.h>

//Inicialização do Display I2C
LiquidCrystal_I2C lcd(0x27,16,2);


int count = 0;                                              //Contador de uso geral
char pass [4] = {'1', '9', '7', '1'};                 //Senha
const int yellowPin = 11;                             //Definição do pino do LED Amarelo
const int redPin = 12;                                 //Definição do pino do LED Vermelho
const int greenPin = 10;                              //Definição do pino do LED Verde
const int audioPin = 9;                                //Definição do pino do Buzzer
const int duration = 200;                             //Duração das sons tocados
const byte ROWS = 4;                              //Quatro linhas
const byte COLS = 3;                               //Três colunas

//Mapeamento de teclas
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {5, 4, 3, 2};                    //Definição de pinos das linhas
byte colPins[COLS] = {6, 7, 8};                          //Definição de pinos das colunas

//Cria o teclado
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
//Programa inicial 
void setup(){
  lcd.init();                                              //Inicializa o LCD
  lcd.backlight();                                     //Com Backlight
  Serial.begin(9600);                              //Inicializa a comunicação serial a 9600 bps
  
  //Deifinição de modo dos pinos
  pinMode(audioPin, OUTPUT);
  pinMode(yellowPin, OUTPUT);
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  lcd.clear();                                        //Limpa LCD
  key_init();                                         //Inicializa o sistema
}



//Loop Principal do Programa 
void loop(){
  char key = keypad.getKey();                         //Obtém tecla pressionada
  if (key != NO_KEY){                                  //Se foi pressionada uma tecla:
    if (key == '#') {                                          //Se a tecla é '#'
      code_entry_init();                                    //Então espera que seja inserida uma senha
      int entrada = 0;
      while (count < 4 ){                                  //Conta 4 entradas/teclas
        char key = keypad.getKey();                //Obtém tecla pressionada
        if (key != NO_KEY){                          //Se foi pressionada uma tecla:
          entrada += 1;                                     //Faz entrada = entrada + 1
          tone(audioPin, 1080, 100);                 //Para cada dígito emite um som de indicação
          delay(duration);                                 //Duração do som
          noTone(audioPin);                            //Para de emitir som
          if (key == pass[count])count += 1;       //Se a tecla pressionada corresponde ao dígito 
                                                                      //da senha correspondente, soma 1 no contador
          if ( count == 4 ) unlocked();                 //Se contador chegou a 4 e com dígitos corretos, 
                                                                     //desbloqueia siatema
          if ((key == '#') || (entrada == 4)){        //Se foi pressionada a tecla "#' ou foram feitas
                                                                     //4 entradas,
             key_init();                                         //Inicializa o sistema
            break;                                               //Para o sistema e espera por uma tecla
          }
        }
      }
    }
  }
}


//Inicializar o Sistema 
void key_init (){
  lcd.clear();                                                //Limpa o LCD
  lcd.print("Aguardando...");                        //Emite mensagem
  lcd.setCursor(0,1);                                   //Muda de linha
  lcd.print("Tecle #");                                  //Emite mensagem
  
  count = 0;                                                //Variável count é zero na inicialização
  
  //Emite som e acende LED Vermelho, indicando Sistema Iniciado
  digitalWrite(redPin, HIGH);
  digitalWrite(yellowPin, LOW);
  digitalWrite(greenPin, LOW);
  tone(audioPin, 1080, 100);
  delay(duration);
  noTone(audioPin);
  tone(audioPin, 980, 100);
  delay(duration);
  noTone(audioPin);
  tone(audioPin, 770, 100);
  delay(duration);
  noTone(audioPin);
}

//Subrotina de Entrada da Senha 
void code_entry_init(){
  lcd.clear();                                                //Limpa LCD
  lcd.print("Entre a Senha:");                        //Emite mensagem
  
  count = 0;                                                //Variável count é zero na entrada de senha
  
  //Emite som e acende LEDs
  tone(audioPin, 1500, 100);
  delay(duration);
  noTone(audioPin);
  tone(audioPin, 1500, 100);
  delay(duration);
  noTone(audioPin);
  tone(audioPin, 1500, 100);
  delay(duration);
  noTone(audioPin);
  digitalWrite(redPin, LOW);                            //Apaga LED Vermelho
  digitalWrite(yellowPin, HIGH);                      //Acende LED Amarelo
  digitalWrite(greenPin, LOW);                        //Apaga LED Verde
}


//Subrotina para Acesso Liberado 
void unlocked(){
  lcd.clear();                                                    //Limpa LCD
  lcd.print("Acesso Liberado!");                       //Emite mensagem
  
  digitalWrite(redPin, LOW);                           //Apaga LED Vermelho
  digitalWrite(yellowPin, LOW);                      //Apaga LED Amarelo
  
  //Executa 20 vezes +- 5 segundos, emite som e pisca LED verde
  for (int x = 0; x < 20; x++){ 
  digitalWrite(greenPin, HIGH);
  tone(audioPin, 2000, 100);
  delay(duration);
  noTone(audioPin);
  digitalWrite(greenPin, LOW);
  tone(audioPin, 2000, 100);
  delay(duration);
  noTone(audioPin);
  delay(250);
  }
}

As bibliotecas deste projeto bem como as versões mais elaboradas estão disponibilizadas em:
https://github.com/Arduinobymyself/ElectronicDoorLock



VÍDEO:
Agora podemos ver o projeto completo

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com



Bom!, espero ter mostrado, o quanto o Arduino é flexível, fácil e dinâmico na realização de projetos.
Até o próximo post.



Como muitos visitantes pediram:

Agora temos uma Atualização do Sistema de Segurança com Arduino.
Sendo possível entar como uma nova senha via teclado.
Lembrando que ela permanece enquanto o sistema estiver ligado (em caso de perda de energia, a senha volta para a senha padrão).

;-)

Abaixo o código completo e uma nova versão da biblioteca LCD via I2C para a IDE 1.0 e da biblioteca keypad

https://github.com/Arduinobymyself/ElectronicDoorLock







25/01/2019 - ATUALIZAÇÃO

NOVA VERSÃO DA TRANCA ELETRÔNICA:


Agora com LCD normal 16x2 e LCD I2C, no mesmo SW você pode escolher entre um e outro somente tirando o comentário de algumas linhas;
Lendo e gravando as passwords diretamente na EEPROM do arduino;
Agora o sistema não perde mais a password  em caso de ser desernergizado;
Conhecendo o password antigo, é possível configurar um novo password que será gravado na EEPROM;
Para efeitos mais práticos de simulção, foi adicionado um servo-motor para fazer o acionamento da tranca;
Os comentários e as Telas do SW agora estão no idioma Inglês (devido a esse projeto estar também hospedado em sites estrangeiros;
quando digitado o password, um máscara com * irá aparecer para não divulgar os números (somente para efeitos especiais, pois os numeros do password não são mostrados enquanto digitados);
Nessa nova edição o teclado foi alterado para o tamanho 4x4, ou seja as senhas agora podem ter letras e números, o comprimento da senha também pode ser alterado na programação inicial do sistema.
Foi acrescentado um RTC Real Time Clock, para mostrar a hora no display na tela principal.
Conta com um temporizador; caso a pessoa não entre a senha correta em 5 segundos, volta para a tela inicial.

Dessa forma algumas mudanças na pinagem e interconexão foram necessárias; siga no próprio software a pinagem para as conexões do sistema.

Todos os arquivos podem ser obtidos diretamente no GitHub da ArduinoByMySelf; incluindo as versões anteriores:
https://github.com/Arduinobymyself/ElectronicDoorLock

BREVE POSTAREI UM VÍDEO RELACIONADO COM ESSA NOVA VERSÃO, AGUARDE!

Qualquer dúvida e ou sugestão entre em contato:
arduinobymyself@gmail.com

15 comentários:

  1. Essa biblioteca é o nome da versão compatível com o IDE v1.0? Onde consigo baixá-la?

    ResponderExcluir
    Respostas
    1. Caro Colega
      pode baixar as duas bibliotecas dos Links Abaixo:

      Esta é para a IDE 1.0
      http://www.4shared.com/rar/QECgzqt1/LiquidCrystal_I2Cv1-1.html?refurl=d1url

      Esta é para o IDE até 0023
      http://www.4shared.com/zip/rzQcuuc0/LiquidCrystal_I2C.html?refurl=d1url

      Felicidades

      Excluir
    2. Existe algum "reference" dessa biblioteca? Meu ponto é: somos novos com arduino e programação e estamos desenvolvendo um projeto cuja base é muito parecida com sua experiência. Gostaríamos de entender melhor o código, principalmente a parte da comunicação I2C com o display, como por exemplo a função: " LiquidCrystal_I2C lcd(0x27,16,2); "

      Excluir
    3. Colega Tails,

      Não encontrei nenhum "reference" desta biblioteca.

      Mas como éla é na verdade uma variação da biblioteca "LiquidCrystal_I2C" padrão, e como podemos observar nos arquivos .h ... todas as funções são correspondentes com a biblioteca padrão, pode-se usar a mesma referência para ambas.

      Uma outra solução, que na verdade estou usando atualmente, pois não é somente esta biblioteca de LCD que não funciona na IDE 1.0, é voltar a usar a IDE 0023, onde todas as bibliotecas funcionam e temos muitas referências disponíveis.
      Até que as novas versões de IDE estejam consolidadas, teremos que conviver com ambas.
      Aconselho estudarem bem a referência da LiquidCrystal padrão, e depois certamente verão que a solução proprietária da biblioteca para a IDE 1.0 é muito parecida. Consultem o Arduino Forum, lá temos muitas informações também.
      No próprio arquivo .h da blibioteca, temos todas as funções e assim verificar o uso.

      Se puder ajudar com mais alguma coisa em seu projeto, ponho-me a disposição.
      Nossa vida é assim mesmo...escarafunchando aqui e ali...

      Excluir
  2. Consultem:
    http://www.arduino.cc/playground/Code/LCDAPI

    Aqui foi onde consegui a versão que funciona com a IDE 1.0
    http://hmario.home.xs4all.nl/arduino/LiquidCrystal_I2C/

    até mais

    ResponderExcluir
  3. http://arduino-info.wikispaces.com/LCD-Blue-I2C

    ResponderExcluir
  4. Uma última pergunta Marcelo: foi fácil conseguir esse display com adaptador I2C? Comprou nessas lojas de componentes mesmo ou teve que pedir pela internet?

    Agradeço desde já

    ResponderExcluir
    Respostas
    1. Tails

      Esse componente é relativamente fácil de conseguir.
      No meu caso eu fiz um pedido de compra direto da China, demorou 15 dias para ser entregue e em ótimo estado.

      http://www.aliexpress.com

      Porém você pode comprar também, por exemplo, no mercado livre ou lojas especializadas.
      Também conhecido como display serial.

      Abraço

      Excluir
  5. Grande Marcelo, parabéns pelo grande trabalho.
    Um abraço!

    ResponderExcluir
  6. o desenho do circuito eletrônico vc pode enviar para mim gilson7@oi.com.br

    ResponderExcluir
  7. Olá Marcelo, e ocorreu uma dúvida, os arduinos duemilanove e arduino uno são iguais e qualquer um dos dois serviria para a tranca ou só o arduino uno? Sou iniciante no arduino didáticamente e resolvi realizar o experimento da tranca de controle de acesso.

    Urias Barbosa

    ResponderExcluir
    Respostas
    1. Olá Urias,
      Acredito que o projeto possa ser implementado sem nenhum problema, usando o Arduino Duemilanove.
      Nunca fiz nenhum teste, porém existe compatibilidade.

      Se necessitar alguma ajuda ou se tiver mais dúvidas, pode entrar em contato: marcelo.moraes.1971@gmail.com

      Acesse: http://www.instructables.com , para mais projetos meus e de outros colaboradores.
      Divulgue o blog "arduinobymyself", para divulgar conhecimento e informação. Software e Hardware livre para todos.


      Abraço

      Marcelo Moraes

      Excluir
  8. Este comentário foi removido pelo autor.

    ResponderExcluir
  9. Olá marcelo, achei muito bom o seu projeto, seria muito dificil modificar o projeto para poder trocar a senha a qualquer momento?, pois seria muito bacana ter essa opção.
    No Aguardo!.

    ResponderExcluir