CONTROLE ELETRÔNICO DE UM PORTÃO DE GARAGEM

__________________________________________________________
Sistemas Digitais 2016/2

Genaro Antonio Mauro Rangel

Vinicius Paulino Marchesini

Vitória /2016
DESCRIÇÃO DO PRODUTO (PROJETO)

O produto consiste em um portão eletrônico de correr (sliding gate) controlado

por microcontrolador. Esse projeto foi implementado com a placa microcontrolada
Arduino/Genuino, esta que possui o microcontrolador Atmel AVR e código fonte
baseado em C/C++. O portão eletrônico representa uma importante ferramenta para
uso residencial e/ou empresarial. Este possui um funcionamento simples e otimizado,
de forma a se adequar em diversas situações. Além disso, pode ser utilizado com o
mínimo de conhecimento prévio, devido ao fato do mesmo ser pensado
principalmentena automação, visando a economia de tempo e recursos.

Figura 1: Diagrama de blocos do sistema digital.

MANUAL DE OPERAÇÃO

Inicialmente, o portão encontra-se fechado, portanto, nenhum botão além do que

abre e fecha irá funcionar. Com os pinos (vermelho, verde, azul e preto) do protoboard
posicionados para frente, em relação ao usuário, existem no lado direito, na terceira
barra de pinos (da esquerda para direita), 4 push-buttons disponíveis, dos quais, de
cima para baixo, são: chave fim de curso para o portão aberto, abrir e fechar o portão,
sensor infravermelho, chave fim de curso para o portão fechado. Na primeira barra de
pinos, ao lado esquerdo, tem-se o primeiro potenciômetro (de cima para baixo),
responsável por ler o valor de tensão do potenciômetro que simula um sensor de
corrente do motor do portão, caso seja muito alta, o motor se desliga. Ainda na primeira
barra de pinos, há o segundo potenciômetro, responsável por ajustar o tempo que o
usuário deseja, para fechar automaticamente, caso o portão fique parcial ou totalmente
aberto durante o tempo estipulado.

MANUAL DE INSTALAÇÃO

1. Abra o arquivo “Simulação de um portão eletrônico.ino” e verifique qual a

pinagem escolhida para os push – buttons, leds, lcd, e potenciometros,
localizado logo abaixo de #include <LiquidCrystal.h>;

2. Com o arduino uno em mãos, posicione – o na parte central do protoboard.

3. Conecte todos os componentes no arduino;

4. Ligue os leds, push – buttons e LCD em 5v, no arduino e os potenciômetros em

3.3v;

5. Conecte os dois grupos de componentes no GND do arduino;

6. Conecte o arduino ao computador, utilizando um cabo USB;

7. Faça upload do arquivo “Simulação de um portão eletrônico.ino” e então o

produto estará pronto para ser utilizado.
Figura 2: Esquema eletrônico do circuito.
DESCRIÇÃO DO FIRMWARE

Dois conceitos básicos foram usados para a construção do programa base do

projeto, um contador e um temporizador. O temporizador foi usado para a regulagem do
tempo de espera para fechar o portão nos casos do mesmo se encontrar parado e
aberto ou de sofrer uma obstrução. A utilização do contador advém do princípio de que
o funcionamento do portão é relativamente simples e linear. O incremento da variável
temporizadora e do contador realizam diversos estados diferentes de movimento do
portão.
Além disso, observou-se a necessidade de uma limitação de corrente, para
proteger as partes físicas do produto, abortando o programa a partir de um valor
determinado de corrente lida pela placa.
A regulagem do tempo foi realizada com um potenciômetro e mostrada em um
display 16/2 para que o usuário tenha perfeita noção da temporização escolhida para o
projeto.
Uma interrupção foi utilizada para o botão principal de controle, tornando
possível o funcionamento do circuito. Além disso, utilizou-se uma forma de debounce
para que os botões fim de curso funcionassem adequadamente.

Utilizando o contador e as demais condições do circuito, obervou-se nove

situações possíveis, denominadas estados. Estes são:

0. Condição inicial. Portão parado e fechado;

1. Portão abrindo. Botão acionado para abrir o portão;

2. Portão parado entreaberto. Estado anterior: abrindo;

3. Portão fechando;

4. Portão parado entreaberto. Estado anterior: fechando;

5. Retorno ao estado 1. Contagem máxima de cliques sem que se alcance algum

fim de curso;

6. Portão totalmente aberto. Fim de curso aberto e estado anterior: abrindo.

Necessário para que o fim de curso aberto acionado enquanto o portão eteja
parado ou fechando não seja considerado;

7. Portão totalmente fechado. Fim de curso fechado e estado anterior: fechando.

Necessário para que o fim de curso fechado acionado enquanto o portão eteja
parado ou abrindo não seja considerado;
 8. Interrupção devido à presença. Feixe infravermelho interrompido e estado
anterior: fechando. Necessário para que o portão pare devido à presença
detectada apenas se o portão estiver fechando.

Todos esses estados foram análisados pela função principal, cujo fluxograma foi
apresentado abaixo na figura 3. O tempo máximo, ou limite, representa o tempo no qual
o portão aberto retorna a fechar. Esse tempo é definido pelo usuário.

O tratamento dado ao botão acionador do portão está descrito na figura 4.

Para a eliminação de algum ruído no botão e nos fins de curso, foi utilizado
debouce por software, descrito no fluxograma da figura 5 .
Figura 3: Fluxograma da rotina principal.
Figura 4: Função do tratamento do botão acionador do portão.
Figura 5: Debounce.
ANEXO A – CÓDIGO FONTE DO FIRMWARE

Definições gerais:

#include <LiquidCrystal.h>
const int botaoPin = 2;
const int fimDeCursoAberto = 3;
const int fimDeCursoFechado = 4;
const int infraVermelho = 5;
const int ledPinVerd = 6;
const int ledPinVerm = 7;
const int potenciometro = A0;
const int pottime = A3;

LiquidCrystal lcd(13, 12, 11, 10, 9, 8);//cria um objeto lcd e

atribui os pinos

int temp = 0;
int cont = 0;
long tempo = 0;

Setup:

void setup() {
Serial.begin(9600);
lcd.begin(16, 2);//inicializa lcd
pinMode(botaoPin, INPUT_PULLUP);
pinMode(fimDeCursoAberto, INPUT_PULLUP);
pinMode(fimDeCursoFechado, INPUT_PULLUP);
pinMode(infraVermelho, INPUT_PULLUP);
pinMode(potenciometro, INPUT);
pinMode(pottime, INPUT);
pinMode(ledPinVerm, OUTPUT);
pinMode(ledPinVerd, OUTPUT);
attachInterrupt (0, radioReceptor, FALLING);}
Função Principal:
void loop() {
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
float POT = analogRead(potenciometro);
Serial.println(POT);

while (1) {
//Delay para contar 5 seg
atualiza();
//delay (50);
Serial.println(POT);
// Tempo de 5 segundo
if (temp == tempo && cont == 2) {
cont = 3;
temp = 0;

}
if (temp == tempo && cont == 4) {
cont = 3;
temp = 0;

}
if (temp == tempo && cont == 6) {
cont = 3;
temp = 0;

}
// Serial.println(temp);
// Serial.println(cont);

//Leitura do potenciometro
if (analogRead(potenciometro) > 500) {
 digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
// Serial.println("Carga muito alta, motor desligado\n");
while (1) {
}
}

//Infravermelho
if (digitalRead(infraVermelho) == LOW && cont == 3) {
delay(100);
if (digitalRead(infraVermelho) == LOW) {
// Serial.println("Portao obstruido \n");
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
cont = 8;
}
}

//Fins de curso
if (digitalRead(fimDeCursoAberto) == LOW && cont == 1) {
delay(100);
if (digitalRead(fimDeCursoAberto) == LOW) {
// Serial.println("Portao totalmente aberto \n");
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
cont = 6;
temp = 0;
}
}

if (digitalRead(fimDeCursoFechado) == LOW && cont == 3) {

delay(100);
if (digitalRead(fimDeCursoFechado) == LOW) {
 // Serial.println("Portao totalmente fechado \n");
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
cont = 7;
}
}

if (temp > 10002) {

temp = 0;
}

//Tratamento de casos do contador

if (cont == 0) {
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
// Serial.println("Portao parado e fechado \n");
}

else if (cont == 1) {
digitalWrite(ledPinVerm, HIGH);
digitalWrite(ledPinVerd, HIGH);
// Serial.println("Portao Abrindo \n");
}

else if (cont == 2) {
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
// Serial.println("Portao parado e aberto\n");
temp++;
}

else if (cont == 3) {
digitalWrite(ledPinVerm, HIGH);
 digitalWrite(ledPinVerd, LOW);
// Serial.println("Portao Fechando \n");
}

else if (cont == 4) {
digitalWrite(ledPinVerm, LOW);
digitalWrite(ledPinVerd, LOW);
// Serial.println("Portao parado e aberto\n");
temp++;
}

else if (cont == 5) {
cont = 1;
}

else {
temp++;
if (cont == 8) {
cont = 3;
}
}
}
}

void atualiza() {
int Tempo = analogRead(pottime);
float Time = Tempo * (150.0 / 1023);

// Serial.println(Tempo);

lcd.print("Tempo p/ fechar:");//escrever na tela lcd

//Serial.println("Temporizacao: ");
lcd.setCursor(0, 1);
if (Time <= 15) {
lcd.print("1 segundo ");
//Serial.println("1 segundo: ");
tempo = 42;
}
if ((Time > 15) && (Time <= 25)) {
lcd.print("2 segundos ");
//Serial.println("2 segundos ");
tempo = 142;
}
if ((Time > 25) && (Time <= 35)) {
lcd.print("3 segundos ");
// Serial.println("3 segundos ");
tempo = 242;
}
if ((Time > 35) && (Time <= 45)) {
lcd.print("4 segundos ");
//Serial.println("4 segundos ");
tempo = 342;
}
if ((Time > 45) && (Time <= 55)) {
lcd.print("5 segundos ");
//Serial.println("5 segundos ");
tempo = 442;
}
if ((Time > 55) && (Time <= 65)) {
lcd.print("6 segundos ");
//Serial.println("6 segundos ");
tempo = 542;
}
if ((Time > 65) && (Time <= 75)) {
lcd.print("7 segundos ");
 //Serial.println("7 segundos ");
tempo = 642;
}
if ((Time > 75) && (Time <= 85)) {
lcd.print("8 segundos ");
//Serial.println("8 segundos ");
tempo = 742;
}
if ((Time > 85) && (Time <= 95)) {
lcd.print("9 segundos ");
//Serial.println("9 segundos ");
tempo = 842;
}
if (Time > 95) {
lcd.print("10 segundos ");
//Serial.println("10 segundos ");
tempo = 942;
}
}
//Funcao de interrupcao do botao
void radioReceptor() {
temp = 0;
if (digitalRead(botaoPin) == LOW) {
delay(100);
if (digitalRead(botaoPin) == LOW) {
if (cont == 6) {
cont = 2;
}
else if (cont == 7) {
cont = 0;
}
cont++;
while (digitalRead(botaoPin) == LOW) {
 delay(30);
}
}
}
}