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.


/*
#################################################################################
#   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 estão disponibilizadas em:

O 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

http://www.4shared.com/file/Arpz0_jh/Tranca_Eletronica_v3.html

http://www.4shared.com/rar/XM6tp24T/LiquidCrystal_I2C.html

http://www.4shared.com/rar/rO36wLIF/Keypad.html







Arquivo da nova versão, onde é possível trocar a senha via teclado:

https://docs.google.com/file/d/0B_YlEklLDDS7aHZ5SFBNUVRnRnc/edit?usp=sharing