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 PID - Controlando a velocidade de um ventilador

Arduino PID - FAN Control

Este post é um complemento do post anterior "Controle de velocidade com Arduino PID".

Desse modo não é necessário nenhum tipo de explicação teórica sobre o projeto a não ser nosso objetivo.


OBJETIVOS:

Queremos agora controlar a velocidade de uma unidade FAN (ventilador) de acordo com um sensor de posicionamento (que mede a distância relativa a  um anteparo).

Quanto maior a velocidade da FAN (maior a ventilação, quantidade de vento), mais longe estará o anteparo; quanto menor a velocidade da FAN (menor ventilação, quantidade de vento), mais perto estará o anteparo.

Para isto utilizei um pêndulo formado por um anteparo superior que coleta o vento da FAN e um anteparo inferior que se moverá em relação ao sensor de distância. Assim, é possível controlar a unidade FAN com a técnica PID e usando o Arduino como controlador e o  FrontEnd_PID como interface gráfica.



Abaixo os detalhes do circuito e os detalhes construtivos.

O sketch utilizado no Arduino é o mesmo do post anterior (http://arduinobymyself.blogspot.com.br/2013/04/controle-de-luminosidade-com-arduino-pid.html)... visite este post para poder ver todos os detalhes.

Este é o link para download do sketch:
http://www.4shared.com/file/Y5BIbUdR/LED_PIDcontroller_2.html

Vejam os vídeos para maiores detalhes.

Interconexão do Arduino com os outros componentes

Esquema do Driver do motor DC (FAN)

Para o driver foi usado um MOSFET IRF-250.
O diodo em paralelo com o motor é um BY-127.
O capacitor é de 100 nF.
Cuidado com o sentido de rotação do motor (para o sistema ser ventilador  e não exaustor).

Esquema do sensor de distância com o TCRT5000, este sensor deve ser analógico!

FOTOS REAIS:

O material utilizado para construir a estrutura metálica é uma tira de metálica perfurada, que pode sem encontrada em casa de materiais de construção em pequenos rolos.
É só dobrar para formar a estrutura.
Use sua imaginação para construir conforme sua necessidade.

A fonte é de 5/12 V e 10A

O motor DC deve ser de alta rotação e ter um bom torque.
Usei um de máquina de cortar cabelos (das de qualidade).

Fonte externa de 5V e 12V/10A

Estrutura metálica e pendulo com os anteparos

Arduino, Driver do motor DC e potenciômetro de ajuste do "Setpoint"

Estrutura metálica e sensor de distância

Driver do motor DC com o MOSFET IRFP-250

Detalhe do driver

Estrutura metálica

Detalhe do pêndulo em ação e da torre do FAN

Sensores: são 3 mas foi utilizado somente o central (esse éra de um seguidor de linha)

Detalhe da torre e do motor DC do FAN

Notar que foi utilizado material de garrafa PET para confeccionar o anteparo superior e a hélice do FAN.
Para construir a hélice, marque dois circulos (unidos), utilize uma moeda de 1 real, recorte e então dobre pelas pontas para dar este formato:       \___ 
                                                                                                     \
e do outro lado faça no modo contrário... pronto feito a hélice.
                                                                 

Detalhe da Hélice

Vista geral do conjunto

Vista geral do conjunto (frente)

Vista geral do conjunto (superior)

Vista geral do conjunto (parte de trás)

Vista geral do conjunto (lateralmente)

VÍDEOS:

Atenção!
Agora o Blog está mudando para a língua Inglesa, tentando alcançar outros continentes.
Desculpe pelo transtorno.
Qualquer dificuldade entre em contato.

Visite meu novo site em:
http://www.instructables.com/id/ArduinoPID-FAN-Controller/

Dúvidas e sugestões para: arduinobymyself@gmail.com
http://youtu.be/stxiWXFUf2Y

http://youtu.be/IqzPXTjiRvQ

http://youtu.be/CVNB4Wrq82g

http://youtu.be/lS7MZwqZ2k4

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