Porta de Garagem Deslizante Automatizada com Arduino Nano
Componentes Necessários
1x Arduino Nano R3
1x Protoboard (para Nano e display OLED)
1x Display OLED 0.96" 128x64 SPI (Adafruit SSD1306)
1x Módulo Relé 4 canais (usa 3)
1x Fonte 5V/220V mini (para alimentar Arduino e relés)
1x Pushbutton 12mm (reset de alarme)
Sensores fim de curso (abre/fecha) + fotocélula de segurança
Receptor de rádio 433MHz + controles remotos (comercial)
Relés de potência 220V para motor
Histórico do Projeto
O controlador original da porta queimou quando um lagarto causou curto-circuito em fastons de 220V. Em vez de comprar outro, decidi reconstruir com Arduino — adicionando recursos que o original não tinha.
⚠️ AVISO DE SEGURANÇA
Este projeto lida com 220V/110V diretamente. Perigoso se você não tem experiência com instalações elétricas. Sempre simule antes de ligar ao motor real. Use relés dimensionados para a corrente do motor.
Arquitetura do Sistema
O projeto tem duas partes:
Unidade de controle principal (Arduino Nano): Lê sensores, aciona relés, gerencia display OLED, implementa lógica de segurança
Circuito de potência: Relés 220V comutam motor, lâmpada de sinalização; receptor RF aciona relé "Abrir"
Melhorias sobre o Controlador Original
Monitoramento de tempo máximo de percurso (detecta travamento)
Fotocélula de segurança: inverte fechamento se obstáculo detectado
Tempo configurável de porta aberta (ex: 30s para entrar carro)
Piscagem da lâmpada com padrões diferentes por estado
Display OLED para diagnóstico sem notebook
Reset de falha por botão físico
Pinout (Resumo)
Pino Nano Função Componente
D2 FOTOCÉLULA Entrada pull-up (ativa LOW = obstáculo)
D3 OBERT Sensor fim de curso ABERTO (pull-up)
D4 OBRIR Sinal do receptor RF (pull-up, ativo LOW)
D5 BOMBETA Relé 1 - Lâmpada sinalização
D6 MOTOR_OBRIR Relé 2 - Motor sentido abrir
D7 TANCAT Sensor fim de curso FECHADO (pull-up)
D12 MOTOR_TANCAR Relé 3 - Motor sentido fechar
D8 OLED_RESET Display OLED SPI
D9 OLED_DC Display OLED SPI
D10 OLED_CS Display OLED SPI
D11 OLED_MOSI Display OLED SPI
D13 OLED_CLK Display OLED SPI
Display OLED - Informações Exibidas
Fase atual: "BUCLE PRINCIPAL", "Obrint porta", "Tancant porta", "Porta Oberta completament", "Esperant ordre..."
Tempo decorrido da ação atual (segundos)
Status: Fotocélula, Sensor FECHADO, Sensor ABERTO, Ordem ABRIR
Indicação de AVARIA (tempo excedido)
Fluxograma do Software
Três fluxogramas principais (disponíveis nas imagens do projeto):
Loop Principal + Sequência Abertura
Sequência Fechamento + Segurança Fotocélula
Espera Porta Aberta + Fechamento Automático
Código Completo (Versão em Inglês)
/*********************************************************************
* Automatismo para porta deslizante motorizada
*********************************************************************/
// Vocabulário: Bucle principal=Main loop, Sequencia Obertura=Opening,
// Sequencia Tancament=Closing, Obrir=Open, Tancar=Close, Bombeta=Lâmpada,
// Porta=Porta, Avaria=Falha, Temps=Tempo, Recorregut=Percurso
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
// Pinos automação
int FOTOCELULA = 2;
int BOMBETA = 5; // Relé 1
int TANCAT = 7; // Sensor fechado
int OBERT = 3; // Sensor aberto
int MOTOR_OBRIR = 6; // Relé 2
int MOTOR_TANCAR = 12; // Relé 3
int OBRIR = 4; // Comando RF
// Pinos OLED SPI
#define OLED_MOSI 11
#define OLED_CLK 13
#define OLED_DC 9
#define OLED_CS 10
#define OLED_RESET 8
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);
// Variáveis globais
unsigned long TEMPS_PORTA_OBERTA = 20000; // 20s porta aberta (ajustado p/ 30s no código)
unsigned long TEMPS_MAXIM_RECORREGUT = 15000; // 15s máx percurso (ajustado p/ 28s)
int interval = 1000;
int TEMPS_DISPLAY = 1;
int DURADA = 300; // Ciclo lâmpada
unsigned long previousMillis = 0;
unsigned long currentMillis = 0;
unsigned long TEMPS_LLUM = 1000;
bool LLUM = false;
bool AVARIA = false;
void setup() {
// Desliga tudo (relés ativos em LOW)
digitalWrite(MOTOR_OBRIR, HIGH);
digitalWrite(MOTOR_TANCAR, HIGH);
digitalWrite(BOMBETA, HIGH);
pinMode(FOTOCELULA, INPUT_PULLUP);
pinMode(TANCAT, INPUT_PULLUP);
pinMode(OBERT, INPUT_PULLUP);
pinMode(OBRIR, INPUT_PULLUP);
pinMode(BOMBETA, OUTPUT);
pinMode(MOTOR_OBRIR, OUTPUT);
pinMode(MOTOR_TANCAR, OUTPUT);
Serial.begin(9600);
display.begin(SSD1306_SWITCHCAPVCC);
display.display(); delay(1000); // Logo Adafruit
display.clearDisplay(); display.display();
display.setTextSize(1); display.setTextColor(WHITE);
}
void loop() {
BUCLE_PRINCIPAL:
delay(2000);
previousMillis = millis();
while (digitalRead(OBRIR) == HIGH) { // Aguarda comando ABRIR (LOW)
atualizaDisplay("BUCLE PRINCIPAL ...");
if (AVARIA && (millis() - previousMillis < 60000)) digitalWrite(BOMBETA, LOW);
else digitalWrite(BOMBETA, HIGH);
}
goto SEQUENCIA_OBERTURA;
SEQUENCIA_OBERTURA:
interval = 28000; // 28s máx abertura
previousMillis = millis();
digitalWrite(MOTOR_OBRIR, LOW); // Liga motor abrir
digitalWrite(BOMBETA, LOW); // Liga lâmpada
delay(1000);
A:
if (digitalRead(OBERT) == HIGH) goto PORTA_OBERTA; // Sensor aberto atingido
if (digitalRead(OBRIR) == LOW) { // Comando fechar durante abertura?
atualizaDisplay("Esperant ordre per tancar");
digitalWrite(MOTOR_OBRIR, HIGH); digitalWrite(BOMBETA, HIGH); delay(1000);
while (digitalRead(OBRIR) == HIGH) {}; // Aguarda novo ABRIR
goto SEQUENCIA_TANCAMENT;
}
// Atualiza tempo e display
currentMillis = millis();
TEMPS_DISPLAY = (currentMillis - previousMillis) / 1000;
atualizaDisplay("Obrint porta", TEMPS_DISPLAY);
if (currentMillis - previousMillis >= interval) {
digitalWrite(MOTOR_OBRIR, HIGH); AVARIA = true;
}
// Pisca lâmpada lento (1Hz)
if (currentMillis - TEMPS_LLUM >= 1000) { LLUM = !LLUM; digitalWrite(BOMBETA, LLUM); TEMPS_LLUM = currentMillis; }
goto A;
SEQUENCIA_TANCAMENT:
interval = 28000; // 28s máx fechamento
previousMillis = millis();
digitalWrite(MOTOR_TANCAR, LOW); digitalWrite(BOMBETA, LOW);
if (digitalRead(TANCAT) == LOW) delay(1000); // Aguarda sensor fechado liberar
B:
if (digitalRead(TANCAT) == HIGH) { // Fechado!
digitalWrite(MOTOR_TANCAR, HIGH); digitalWrite(BOMBETA, HIGH);
goto BUCLE_PRINCIPAL;
}
if (digitalRead(OBRIR) == LOW) { // Comando abrir durante fechamento?
atualizaDisplay("Esperant ordre per obrir");
digitalWrite(MOTOR_TANCAR, HIGH); digitalWrite(BOMBETA, HIGH); delay(1000);
while (digitalRead(OBRIR) == HIGH) {};
goto SEQUENCIA_OBERTURA;
}
if (digitalRead(FOTOCELULA) == HIGH) { // Obstáculo!
digitalWrite(MOTOR_TANCAR, HIGH); delay(1000);
goto SEQUENCIA_OBERTURA; // Reabre
}
currentMillis = millis();
TEMPS_DISPLAY = (currentMillis - previousMillis) / 1000;
atualizaDisplay("Tancant porta", TEMPS_DISPLAY);
if (currentMillis - previousMillis >= interval) {
digitalWrite(MOTOR_TANCAR, HIGH); AVARIA = true; goto BUCLE_PRINCIPAL;
}
// Pisca lâmpada rápido (300ms)
if (currentMillis - TEMPS_LLUM >= 300) { LLUM = !LLUM; digitalWrite(BOMBETA, LLUM); TEMPS_LLUM = currentMillis; }
goto B;
PORTA_OBERTA:
interval = 30000; // 30s espera antes de fechar
previousMillis = millis();
digitalWrite(MOTOR_OBRIR, HIGH); delay(500);
C:
if (digitalRead(OBRIR) == LOW) goto SEQUENCIA_TANCAMENT; // Comando fechar antecipado
currentMillis = millis();
TEMPS_DISPLAY = (currentMillis - previousMillis) / 1000;
atualizaDisplay("Porta Oberta completament", TEMPS_DISPLAY);
if (currentMillis - previousMillis >= interval) goto SEQUENCIA_TANCAMENT;
// Pisca especial: curto 100ms, longo 2s
if (!LLUM) DURADA = 100; else DURADA = 2000;
if (currentMillis - TEMPS_LLUM >= DURADA) { LLUM = !LLUM; digitalWrite(BOMBETA, LLUM); TEMPS_LLUM = currentMillis; }
goto C;
}
void atualizaDisplay(String fase, int tempo) {
display.clearDisplay();
display.setTextSize(1); display.setCursor(0, 0); display.println(fase);
display.setTextSize(2); display.setCursor(90, 0); display.println(tempo);
display.setTextSize(1); display.setCursor(0, 20);
display.print("Fotocel.lula: "); display.println(digitalRead(FOTOCELULA));
display.print("Sensor TANCAT: "); display.println(digitalRead(TANCAT));
display.print("Sensor OBERT: "); display.println(digitalRead(OBERT));
display.print("Ordre OBRIR: "); display.println(!digitalRead(OBRIR));
display.display();
}
void atualizaDisplay(String fase) { atualizaDisplay(fase, 0); }
Esquemáticos e Arquivos
Esquemático Fritzing (imagem + arquivo .fzz)
Lista de pinouts (arquivo .txt)
Adendo hardware para expansão (imagem)
Observações Finais
O código usa goto para máquina de estados simples — funcional, mas para projetos maiores recomenda-se switch-case com enum de estados. O OLED SPI economiza pinos vs. I2C e permite diagnóstico local. O sistema está em uso real há anos.