Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Porta de Garagem Deslizante Automatizada com Arduino Nano

Componentes Necessários

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.

Porta de Garagem Deslizante Automatizada com Arduino Nano

⚠️ 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:

  1. Unidade de controle principal (Arduino Nano): Lê sensores, aciona relés, gerencia display OLED, implementa lógica de segurança
  2. Circuito de potência: Relés 220V comutam motor, lâmpada de sinalização; receptor RF aciona relé "Abrir"

Melhorias sobre o Controlador Original

Pinout (Resumo)

Display OLED - Informações Exibidas

Porta de Garagem Deslizante Automatizada com Arduino Nano

Fluxograma do Software

Três fluxogramas principais (disponíveis nas imagens do projeto):

  1. Loop Principal + Sequência Abertura
  2. Sequência Fechamento + Segurança Fotocélula
  3. 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

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.

Processo de manufatura

  1. Breakout Compacto DHT de Temperatura e Umidade para Raspberry Pi – ATtiny85 & DHT22/DHT11
  2. Principais Acessórios para Desbloquear Todo o Potencial do Seu Raspberry Pi
  3. SIGHT: Óculos Inteligentes Capacitando Cegos
  4. Construindo um Drone Subaquático com Raspberry Pi: Design, Desenvolvimento e Montagem
  5. Automação de Cabeçote Deslizante de Precisão para Torneamento Suíço e de Produção
  6. Impulsionando o Crescimento: Como a Automação Capacita PMEs para um Futuro Brilhante
  7. Uma Despedida Sentida: Minha Jornada de 40 Anos na Publicação
  8. Como Selecionar Amortecedores de Alta Qualidade para Seu Veículo
  9. Serra de Fita Manual: Solução de Corte Durável e Portátil para Qualquer Projeto
  10. O que é uma Prensa de Potência Automática? – A Máquina Definitiva de Conformação de Chapas Metálicas
Pino NanoFunçãoComponente
D2FOTOCÉLULAEntrada pull-up (ativa LOW = obstáculo)
D3OBERTSensor fim de curso ABERTO (pull-up)
D4OBRIRSinal do receptor RF (pull-up, ativo LOW)
D5BOMBETARelé 1 - Lâmpada sinalização
D6MOTOR_OBRIRRelé 2 - Motor sentido abrir
D7TANCATSensor fim de curso FECHADO (pull-up)
D12MOTOR_TANCARRelé 3 - Motor sentido fechar
D8OLED_RESETDisplay OLED SPI
D9OLED_DCDisplay OLED SPI
D10OLED_CSDisplay OLED SPI
D11OLED_MOSIDisplay OLED SPI
D13OLED_CLKDisplay OLED SPI