Controle de abertura de porta com o Arduíno (MIC009)

Nesta montagem é possível fazer um contador para monitorar quantas vezes uma determinada porta foi aberta, além de emitir um sinal sonoro avisando que a porta foi aberta.

Monitorar quantas vezes uma porta foi aberta, ou emitir um ruído sonoro quando uma pessoa abre uma gaveta ou geladeira, pode ser a necessidade de alguns leitores, além do prazer de fazer uma simples montagem utilizando um microcontrolador. O que apresentamos neste projeto é um contador de eventos que utiliza um LDR, o qual pode ser simplesmente substituído por outros tipos de sensores ou chaves.
Além disso, teremos a oportunidade de trabalhar com o Arduíno em conjunto com um display LCD de 2 linhas.
Utilizamos neste artigo o Tatuíno, versão da Tato do Arduíno, com o kit eletrônico fornecido pela Modelix, com um estojo com diversos componentes, fenolites, conectores e uma matriz de contatos. Há um kit fornecido pela Modelix que já vem com o Arduíno embutido.
Não mostraremos como se faz para instalar o compilador e como funciona o Arduíno, o que já foi apresentado em artigos anteriores, e vamos diretamente para a montagem do projeto. Para os leitores que desejam saber mais sobre o Arduíno, recomendo a leitura de artigos que se encontram neste site "Na onda do Arduíno" ou no site da própria equipe de desenvolvedores do Arduíno (www.arduino.cc).


A lógica do funcionamento
O sistema consiste em ligar o Arduíno, que ficará em loop até que o LDR entre em condução, neste momento o display que está exibindo “Área restrita” na primeira linha e “fechado 0” na segunda, emitirá um sinal sonoro pelo buzzer e exibirá “aberto 1” na segunda linha. A cada vez que o LDR conduzir, será emitido o sinal e será acrescido mais um no número de acesso. A reinicialização do processo, ou seja, a volta ao número “0” é feita pressionando-se o pino Reset do Arduíno.


O display
O display utilizado neste sistema é um exemplar de 2 linhas por 16 caracteres. Este tipo de display possui alguns pinos de contato externo, mas os dados são passados pelos pinos D0 a D7. Iremos utilizar os pinos D4 a D7, porém não precisaremos nos preocupar como e o que deveremos passar através destes pinos para apresentar os dados, isso porque na hora de compilarmos o código-fonte estaremos adicionando uma biblioteca chamada LiquidCrystal.h, que faz todo o trabalho de pegar a frase que digitamos ou as variáveis que desejamos apresentar no display e exibi-las.
Os pinos D4 a D7 estão conectados aos pinos 5 a 2 do Arduíno. Os pinos RW e o GND do display estão conectados ao pino GND do Arduíno, o pino +5V do display ao pino de +5V do Arduíno.
O pino V0 do display controla a luminosidade dos caracteres exibidos, por este motivo conectamos este pino ao potenciômetro que está ligao entre o +5V e o GND do Arduíno, e conforme giramos o potenciômetro temos maior ou menor nitidez do display.
Na figura 1 temos o esquema elétrico do projeto onde vemos as conexões entre o display e o Arduíno.


Figura 1 – Esquema elétrico.


O LDR e o buzzer
Na mesma figura 1 podemos observar que o LDR está conectado ao pino 8 do Arduíno, lembrando que através do código-fonte ele foi setado como Input, ou seja, irá receber um sinal, forçando o microcontrolador a entender que aquele pino será de entrada.
Porém o inverso deve ser feito com o buzzer, onde o pino 9 em que está conectado deverá ser setado como saída. Podemos dar dois tipos de saídas através da programação, podendo ser saída digital ou analógica. Na saída digital temos somente dois estados, alto e baixo, e na saída analógica temos 255 etapas de saídas. Para emitirmos um sinal agradável, vamos enviar para o Buzzer um sinal PWM formando uma frequência definida por código, por este motivo é bom utilizar os pinos 3, 5, 6, 9, 10 ou 11. Tanto no buzzer como no botão é bom colocar um resistor de 220 ohms para evitar picos.


O Código-Fonte
No box 1 onde temos o código-fonte podemos observar alguma linhas já comentadas, mas para melhorar o entendimento, descrevo a seguir o passo-a-passo do programa, que tem o seu fluxograma apresentado na figura 2.


Figura 2 – Fluxograma do sistema.

1. Na primeira linha (#include) inserimos a biblioteca LiquidCrystal.h, que já vem com o compilador do Arduíno, nesta biblioteca temos todas as funções de entrada e saída para a comunicação com o display, ficando para o desenvolvedor apenas chamar as suas funções e passar as variáveis, tais como os pinos de comunicação. Em nosso caso usamos os pinos 2, 3, 4, 5, 11 e 12.
2. Através do comando lcd.begin(caractere,linha) inicializamos e indicamos o formato do display, que em nosso caso é de 16 caracteres por 2 linhas, e no comando lcd.print(String) enviamos o texto para o display exibir. O comando lcd.setCursor(caractere,linha) indica onde o primeiro caractere deverá ser impresso, na primeira vez que enviamos a frase “Área restrita” não usamos a posição que gostaríamos em que ela fosse exibida, e por este motivo ela assume a posição zero na linha 0, lembrando que em programação é comum começarmos qualquer evento com 0 “zero”. Se observarmos na primeira linha que está dentro da função “loop”, veremos que o comando lcd.setCursor(caractere,linha) é chamado posicionando o cursor no primeiro caractere na segunda linha. Como o primeiro caractere é indicado por zero e a segunda linha indicada por um, temos o comando lcd.setCursor(0,1).
3. Nas quatro linhas abaixo da linha #include criamos as variáveis  que nos ajudarão a manipular os pinos de entrada e saída, como é o caso da variável “buttonPin”, que habilitará o pino 8 como entrada na função pinMode(buttonPin, INPUT) para receber o sinal vindo do LDR, e da variável “sirene” que habilitará o pino 9 como saída para acionarmos o buzzer. A outra variável é o “contador”, que tem como função armazenar o número de vezes que a porta foi aberta, e finalmente a variável “auxiliar” que servirá de apoio e indicação do atual estado da porta, onde true indica que a função de adicionar e tocar o buzzer já foi feita.
4. Ainda dentro da função loop() temos a condição “if”, que analisa se o LDR está conduzindo através da função digitalRead(buttonPin). Se o LDR estiver realmente conduzindo, esta condição se torna verdadeira, acionando as linhas dentro da condição “if”.
5. Após esta primeira condição ser atendida, encontramos outra condição que verifica se a variável “auxiliar” é verdadeira ou falsa, se for verdadeira ela toca o buzzer e soma a variável contador, e no final ela modifica a própria variável “auxiliar” para falsa. O motivo desta variável é pelo fato de que o loop do microcontrolador será executado a cada milissegundo, o LDR irá conduzir de alguns milissegundos até dias, se a variável “auxiliar” não mudasse seu estado para falso as linhas dentro dessa condição iriam executar sempre, ou seja, esta variável serve para executar somente uma vez quando o LDR conduz. Depois que o LDR parou de conduzir a variável “auxiliar” volta ao estado True, mas ele não incremente a variável contador e nem aciona o buzzer porque  a condição que analisar o estado do LDR não será atendida.
6. Depois de passar pela segunda condição, ou seja, LDR conduzindo e variável “auxiliar” sendo verdadeira, encontramos outra condição que é o “for (int i=0; i<=10; i++)”, e esta condição irá executar 10 vezes as linhas aninhadas a ele.
7. Dentro deste comando “for” temos o comando “analogWrite(sirene,50),” este comando tem como função enviar um sinal elétrico de forma analógica para o pino “sirene”, esta saída analógica está na faixa de 0 a 255, onde 255 é a corrente máxima e 0 a interrupção ela. Logo abaixo desta função temos um pequeno delay que deixará a saída do pino “sirene” em 50 por um tempo, até o momento em que a mesma função “analogWrite(sirene,0)” seja chamada novamente, porém como a saída analógica está setada em zero o sinal é interrompido. Este sinal fica interrompido por um outro delay de 20 milissegundos. É desta forma, alternando estes estados do pino “sirene”, que mudamos o tom e o tempo do buzzer.
8. No final da condição “if” pegamos a variável “contador” e adicionamos mais 1 a ela (contador++), e por fim enviamos ao display.

É fácil notar que todo o código apresentado se divide em três etapas, onde na primeira delas temos as inclusões das biblioteca e a criação das variáveis, na segunda temos a função “setup()” onde setamos os pinos como entrada e saída, e na terceira a função “loop()” onde o código escrito dentro dele ficará rodando infinitamente até algo o interromper.
Se não existisse a possibilidade de inserir a biblioteca LiquidCrystal.h no código, teríamos um código-fonte bem extenso, tratando as saídas passo a passo para o display, e isso é que torna o Arduíno uma ferramenta útil para simulações de projetos ou como o próprio projeto final.

Código-fonte

#include <LiquidCrystal.h>
int buttonPin = 8;
int contador = 0;
int sirene = 9;
boolean auxiliar = false;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Indicamos os pinos que serão utilizados pelo LCD

void setup() {
lcd.begin(16, 2); // inicializa o display indicando quantidade de linhas e caracteres
lcd.print("Area restrita"); // escreve no display Area restrita
pinMode(buttonPin, INPUT); // Seta o pino do LDR
pinMode(sirene, OUTPUT);  // Seta o pino do buzzer
}

void loop() {
if(digitalRead(buttonPin)) { // LDR está conduzindo?
lcd.setCursor(0, 1); // posiciona o cursor do display
lcd.print("Aberto  ");
lcd.setCursor(8, 1);

if(auxiliar){ // a variável auxiliar é verdadeira?
for (int i=0; i<=10; i++) // repete as linhas entre {} 10 vezes
{
analogWrite(sirene, 50); // saída analógica no pino sirene
delay(70); // tempo de espera
analogWrite(sirene, 150);
delay(50);
analogWrite(sirene, 0);
}
contador++; // acrescenta mais um ao contador
auxiliar=false; // torna variável em false
}
} else {
auxiliar = true;
lcd.setCursor(0, 1);
lcd.print("Fechado ");
lcd.setCursor(8, 1);
}

lcd.print(contador); // exibe no display quantas vezes a porta abriu.
}

Instalando o sensor
Como foi dito no começo do artigo, é possível utilizar diversos tipos de sensores e chaves, por este motivo a instalação pode variar, em nosso caso iremos utilizar um LDR com um tubinho preto para filtrarmos a luz no batente fixo da porta, e um pequeno obstáculo para a luz, feito com uma pequena chapinha com uma fita isolante. Na figura 3, temos como pode ser montado o sensor.


Figura 3 – Instalação do LDR e do Bloqueio.


Conclusão
Todas as vezes que me vejo frente a um novo projeto, depois de esquematizá-lo, saio em busca de pequenos trechos já resolvidos por outros desenvolvedores e que podem ser implementados no projeto. Muitos, assim como eu, gostam de mostrar os resultados obtidos com o seu trabalho, e isso me ajuda bastante. Então conforme vou encontrando soluções, tanto na internet como em revistas, começo a copiar e colar esquemas e códigos, porém gosto de entender o funcionamento dos projetos encontrados, primeiro porque procuro melhorar e otimizar o código copiado, e segundo porque se o sistema apresentar algum problema, tenho meios de  resolver. Por estes motivos resolvi apresentar este projeto básico, pois se para mim foi útil, num projeto maior também será proveitoso para outros.