Sistema de Segurança e Controle de Acesso - Nova Versão

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);

Sistema de Segurança e Controle de Acesso com RFID e Arduino
Este projeto, é uma evolução do projeto original "Arduino - Sistema de Segurança, Controle de Acesso"
veja em: http://arduinobymyself.blogspot.com.br/2012/03/arduino-sistema-de-seguranca-controle.html

Agora ao invés de usarmos um teclado para entradas de senha e para a liberação de uma porta ou acionamento de um dispositivo; usaremos um RFID (Radio Frequency Identifier Device) dispositivo de identificação via rádio frequência.
Usaremos também um display LCD com 20 caracteres e 4 linhas para mostrar as mensagens do sistema, além de um servo-motor para efetuar o acionamento mecânico de travamento/liberação de uma porta ou outros disposivos (tais como catraca, fechaduras, etc...).

O componente RFID é o MFRC522AN (MiFare RC522AN 13.56 MHz comunicação SPI) que pode ser facilmente encontrado em sites do brasil ou da china e por um preço acessível.
http://www.fystore.com/p42892/RFID-module-Kits-S50-13-56-Mhz-6cm-With-Tags-SPI-Write-amp-Read-for-arduino-uno-2560.html


FUNCIONAMENTO:

Os usuários terão cartões e ou tokens/tags de acesso cadastrado no software ou em uma memória.
Ao aproximar o cartão/token/tag do sensor RFID (aproximadamente 6 cm), o número serial deste cartão/token/tag é detectado e assim  comparados com os seriais que estão cadastrados no software ou numa base de dados em uma memória; se for um número de serial cadastrado, o sistema libera a entrada deste usuário acendendo um LED verde e colocando mensagens de reconhecimento do usuário e de boas vindas no display LCD, alem de um servo-motor ser acionado para liberar um dispositivo mecânico. Caso contrário, o sistema não libera o acesso do usuário, acendendo um LED vermelho de advertência e mostrando mensagem no display LCD para o usuário contactar a administração.
Durante o processo de liberação ou rejeição dos usuários, sinais sonoros característicos serão tocados em um buzzer.



MATERIAL:

1 x Arduino UNO, MEGA, Duemilanove ou Teensy, etc...
1 x RFID MFRC522AN (comunicação SPI)
1 x servo-motor
1 x LCD 20x4 I2C
1 x LED verde
1 x LED vermelho
2 x reistor de 220R
1 x Buzzer
1 x Bread Board
Fios e cabos para as ligações 



COMPONENTES:

Cartões e Tags RFID

Token ou Tag

Parte traseira do display LCD 20x4 I2C

Pinagem do LCD I2C:
GND > GND do Arduino
VCC > +5V do Arduino
SDA > pino A4 do Arduino
SCL > pino A5 do Arduino

Parte frontal do display LCD 20x4 I2C

Módulo RFID MFRC522AN

Pinagem e interligação com arduino UNO e MEGA

INTERLIGAÇÃO:


Para o Arduino UNO temos:
Reset > Pin 5
SS > Pin 10
MOSI > Pin 11
MISO > Pin 12
SCK > Pin 13
Ground > Ground
3.3v > 3.3v

Projeto completo:

Lembrar que o LCD é I2C e 20x4 e o RFID é o MFRC522AN.
Buzzer, servo e outros componentes são de uso geral.

Projeto completo

PROGRAMAÇÃO:

Os arquivos foram depositados no google drive, para acessar, crie sua conta.


Este é o sketch para o arduino, deve ser colocado em uma pasta com o mesmo nome do arquivo. https://docs.google.com/file/d/0B_YlEklLDDS7SzhtU1BhZGMxMW8/edit?usp=sharing

Este é o arquivo de nome "pitches.h", necessário para tocar as notas musicais e sons, ele deve estar na mesma pasta do sketch do Arduino.
https://docs.google.com/file/d/0B_YlEklLDDS7cmVDQmRpT29xRlE/edit?usp=sharing

Aqui está o link para a biblioteca RFID:
https://drive.google.com/file/d/0B_YlEklLDDS7dDVkaHNVVG5vcjQ/edit?usp=sharing


Todos os arquivos podem ser obtidos no GitHub:
https://github.com/Arduinobymyself/ArduinoRFID.git VIDEO & FOTOS:

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


Este é um video preliminar, somente para visualizar o funcionamento geral.

http://youtu.be/2O7IVOfFptA




Este é o vídeo oficial em Inglês:
http://youtu.be/fuWf0W6yNo4

Vista Geral

Componentes na BreadBoard

Display e RFID tag

Display, RFID tag/card

Mensagem de ID encontrado

Mensagem de acesso garantido

Mensagem de acesso negado

Arduino - Sistema de Segurança, Controle de Acesso

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

http://www.fisicarduino.com/index.php/projetos/5-keypad-teclado-matricial-controle-de-acesso-com-arduino

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