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

Controle de Luminosidade com Arduino PID

Controle de luminosidade utilizando controlador PID (proporcional Integral Derivativo).

Controlador proporcional integral derivativo, controlador PID ou simplesmente PID, é uma técnica de controle de processos que une as ações derivativa, integral e proporcional, fazendo assim com que o sinal de erro seja minimizado pela ação proporcional, zerado pela ação integral e obtido com uma velocidade antecipativa pela ação derivativa.

É baseado na resposta da modelagem matemática de uma malha de processo a ser controlada.

Na prática os PID são encontrados no interior de controladores eletrônicos chamados "single-loop", muitas vezes com microprocessadores, e também através de software em Controladores programáveis e outros equipamentos de controle.

Neste projeto, vamos simular um controle de luminosidade com Arduino, rodando a biblioteca PID que pode ser encontrada no site:

http://playground.arduino.cc/Code/PIDLibrary

Para isso necessitamos baixar além da biblioteca PID para o Arduino, também o PID Front-End para processing, que é uma interface gráfica para podermos configurar os parâmetros: P, I, D, Set Point, modos de trabalho, etc...; fazendo a interface com o Arduino.

Você pode baixar o Front-End no link acima.

Como vamos trabalhar com Arduino e Processing, necessitamos ter a IDE 1.0.1 do arduino e o Processing 2.0b8 instalados no computador.

Para o Processing, precisamos da biblioteca ContorlP5 para processing instalada. Baixe a biblioteca no site:

http://www.sojamo.de/libraries/controlP5/#installation

Para mairoes detalhes sobre controle PID de processos, aconselho a visitarem o site do criador da Biblioteca PID_V1.

http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/

E o site do Control Guru para maiores detalhes sobre automação e controle.

http://www.controlguru.com/pages/table.html

Detalhes sobre sistemas de controle em:

http://www.facstaff.bucknell.edu/mastascu/econtrolhtml/CourseIndex.html

Vamos agora aos aspectos construtivos do nosso projeto:

Faremos dois testes; um com o ambiente simulado por um tubo escuro, que não admite interferência externa, e o outro aonde poderemos interferir externamente e verificar a resposta do sistema.

Teste - 1

O ambiente será simulado por um tubo negro, com um LED Branco brilhante em uma das pontas (para iluminar o "ambiente") e um LDR na outra ponta (para podermos gerenciar a quantidade de luminosidade no "ambiente").

A ligação com o arduino é muito simples:

Pino D3 (como output) ligado ao LED que tem um resistor de R220 para controlar a corrente.

Pino A0 ligado ao LDR que tem um resistor de pull-down de 10K.

Abaixo o circuito desenhado com o fritzing e fotos reais do sistema.

Entre o LED e o LDR existe um tubo preto vedado, simulando ambiente totalmente escuro

Detalhe do tubo preto (foi utilizado um carretel de linha, vedado por dois passadores de fios de borracha

Detalhe do lado LED

Detalhe do lado LDR

Teste - 2

Agora o ambiente pode sofrer ações externas,chamados de distúrbios do nosso sistema, tais como: sombras e ou luz excessiva no ambiente.
Os distúrbios serão automaticamente controlados pelo Arduino PID.

Outro detalhe é que o valor do Setpoint, é controlado por um potenciômetro, não sendo mais necessário usar o Setpoint do PID_FrontEnd.

Abaixo o circuito desenho em fritizing e as fotos reais do sistema.

Controle do SetPoint feito pelo potenciômetro

Controle via Software:

1 - Descarregar e descompactar as bibliotecas;

PID_V1 no diretório de bibliotecas da IDE do Arduino

Front-End PID, em uma pasta no seu micro

ControlP5, no diretório de bibliotecas do Processing

2 - Iniciar a IDE do Arduino e abrir o arquivo "PID_FrontEnd_ArduinoSampleCode" da pasta PID_FrontEnd.
Enviar este scketch para o arduino.

3 - Iniciar o Processing e abrir o arquivo "PID_FrontEnd_v03" da pasta PID_FrontEnd.
Executar a aplicação.

Abaixo algumas figuras:

Pastas pertencentes ao PID_FrontEnd.

O arquivo PID-FrontEnd_v03, deve ser aberto no Processing e executado

O arquivo PID_FrontEnd_ArduinoSampleCode, deve ser aberto na IDE do Arduino e enviado

IDE Arduino e Processing, é só enviar e executar.

Ao executar a aplicação no Processing, a janela PID_FrontEnd irá abrir.

SetPoint = 950, Kp=0,01, Ki=0,28 e Kd=0

Nesta janela, podemos notar:

TOGGLE_AM - muda o modo para automático PID ou manual;

SETPOINT - valor desejado de luminosidade no ambiente;

INPUT - valor real de luminosidade do ambiente (medido pelo LDR e retornado como feedback medido no pino A0);

OUTPUT - valor de controle retornado pelo Arduino como controlador PID (controle de luminosidade do LED no pino D3);

KP - constante de controle proporcional;

KI - constante de controle Integral;

KD - Constante de controle Derivativo;

TOOGLE_DR - muda a direção (se a saída cresce conforme cresce a entrada ou o inverso);

SEND_TO_ARDUINO - enviar os dados para o arduino;

PID Input/Setpoint - Janela gráfica das curvas setpoint (valor desejado de luminosidade) e entrada (medida de luminosidade do LDR)

PID Output - Janela gráfica da curva de saída de controle do LED

Linha verde = Set Point SP; Linha Vermelha = Variável Controlada PV; Linha Azul = Variável Manipulada MV

Nesta figura, podemos notar o setpoint configurado para 950 (linha verde), a variável de entrada (linha vermelha) sofrendo o controle PID e a variável de saída (linha azul) para controle da luminosidade.

Podemos entender também as informações descritas acimas através de um diagrama de blocos (figura abaixo).
Onde podemos notar o que o Error = SP - PV e o erro é aplicado ao controlador PID que gera a MV para o controle do processo.

Cada controlador P, I, e D pode ser utilizado independentemente, ou de forma conjunta, tal como:
Controlador P (muito utilizado)
Controlador PI (muito utilizado)
Controlador PD (raramente utilizado)
Controlador PID (o mais usado)

Exemplo de Controlador PI com realimentação direta

Aqui nesta figura, observamos uma variação no valor do setpoint (de 950 para 700 e para 950) e a atuação do controle PID em cima da variável de entrada.

Vejam que houve um pouco de oscilação no controle (característica de cada sistema controlado, de primeira ou segunda ordem).

Para o segundo teste, vamos enviar para o Arduino, o sketch abaixo:

(este será usado em lugar do arquivo "PID_FrontEnd_ArduinoSampleCode")

http://www.4shared.com/file/Y5BIbUdR/LED_PIDcontroller_2.html

Lembrando que o controle do Setpoint é feito pelo potenciômetro.

Como fonte de distúrbio, podemos usar uma lanterna para incidir mais luz ou um anteparo para fazer sombra no LDR.

Ao temos um distúrbio no processo (por exemplo sombra), o controlador irá aumentar/diminuir a luminosidade do LED para tentar manter a saída sob controle e no nível estabelecido pelo SetPoint (no caso de fazer uma "sombra no LDR, o controlador irá aumentar a intensidade de luz do LED), poderemos ver estas variações no PID_FrontEnd de forma gráfica.

Abaixo algumas figuras relacionadas.

Kp=0, Ki=10, Kd=0 -- aplicação de disturbio e variações no SP

Kp=0, Ki=10, Kd=0 -- aplicação de disturbio (com bloqueio e sem bloqueio)

A seta indica a mudança de parametros Kp=0,01; Ki=0,28; Kd=0 (notar que a atuação ficou mais lenta e com menos overshoot)

 Ao testar os parametros, foi verificado um comportamento semelhante para os dois testes.

Vídeos explicativos:

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

http://youtu.be/dMdtjuw9Npo

http://youtu.be/Y267-qba12M

No Próximo Projeto, irei apresentar mais um exemplo de controle PID
Aguardem!

Estudos Futuros e mais aprofudados:
http://en.wikipedia.org/wiki/Controller_(control_theory)
http://en.wikipedia.org/wiki/Control_theory
http://en.wikipedia.org/wiki/PID_controller
http://en.wikipedia.org/wiki/Process_control
http://ctms.engin.umich.edu/CTMS/index.php?example=Introduction&section=SystemModeling