Garagem

Este projeto demonstra como construir uma garagem automatizada utilizando um diodo laser e um sensor LDR (Light Dependent Resistor) como barreira óptica. Quando o feixe do laser é interrompido, o portão abre imediatamente. Quando o feixe retorna ao sensor, o sistema aguarda 5 segundos e fecha automaticamente.

Para reduzir interferência da luz ambiente, foi projetado e impresso em 3D um tubo/filtro óptico para o LDR e um suporte dedicado para o laser, aumentando a precisão e estabilidade do sistema.

Lista de materiais

• BlackBoard Edge-H (ESP32)
• Diodo Laser 5V
• Sensor LDR 5mm
• Micro Servo Motor SG90
• Resistor 10k?
• Jumpers
• Protoboard 400 pontos
• Filamento PLA
• Estrutura impressa em 3D (suporte do laser e tubo do LDR)

---

Arquivos STL

Utilize o botão abaixo para fazer o download do modelo 3D da estrutura.

Arquivo STL (.3mf)

Ligações elétricas

LDR (Divisor de tensão):

• 3V3 -> LDR -> Pino 35 (ADC)
• Pino 35 -> Resistor 10k -> GND

Servo Motor:

• Sinal -> GPIO 13
• VCC -> 5V
• GND -> GND

Laser:

• VCC -> 5V
• GND -> GND

Lógica do sistema

O sistema aprende automaticamente os valores mínimos e máximos do LDR durante os primeiros 8 segundos de funcionamento.

Regra adotada:
- Com LASER no LDR -> leitura tende ao MÁXIMO
- Sem LASER no LDR -> leitura tende ao MÍNIMO

A partir desses valores, é criada uma escala normalizada de 0 a 100%:
0% = MIN (sem laser)
100% = MAX (com laser)

Foi aplicada histerese para evitar oscilações:
- Acima de 70% -> Feixe OK
- Abaixo de 30% -> Feixe interrompido

Comportamento final:
- Interrompeu o feixe -> abre imediatamente
- Feixe voltou -> aguarda 5 segundos e fecha

Código

Utilize o código implementado no projeto original Arduino. Caso necessário, realize ajustes conforme sua aplicação.

/************************************************************************************ * Projeto: Garagem - Barreira Óptica (Laser + LDR) + Servo (Portão) * Placa: BlackBoard Edge-H (ESP32) * * Regra adotada: * - Com LASER no LDR => leitura tende ao MÁXIMO (MAX) * - Sem LASER no LDR => leitura tende ao MÍNIMO (MIN) * * O código cria uma escala 0?100% baseada em MIN e MAX: * - 0% = MIN (sem laser) * - 100% = MAX (com laser) * Para evitar o caso da luz ambiente interferir, criamos um * desenho e imprimimos em 3D um filtro para luz ambiente. Assim como suporte para Laser * Lógica: * - Se feixe for interrompido -> abre portão imediatamente * - Quando feixe voltar -> aguarda 5s e fecha * *Robocore Autor: Alexandre Casemonstro ************************************************************************************/ #include <ESP32Servo.h> /* ========================= PINOS (ajuste se quiser) ========================= */ const int PIN_LDR = 35; // usei mapa de pinos na pagina da Edge para me localizar const int PIN_SERVO = 13; // GPIO PWM /* ========================= SERVO: posições X = portão fechado Y = portão aberto ========================= */ int SERVO_FECHADO = 130; // X Esse angulo pode variar de acordo como vc prendeu a palheta no servomotor, eu recomendo seguir a foto do tutorial int SERVO_ABERTO = 20; // /* ========================= TEMPOS ========================= */ const unsigned long TEMPO_PARA_FECHAR_MS = 5000; // 5s depois que o feixe volta const unsigned long LOOP_DELAY_MS = 15; // loop suave /* ========================= FILTROS / ESCALA ========================= */ const int AMOSTRAS_MEDIA = 12; // média simples do ADC (reduz ruído) const int MARGEM_MINMAX = 20; // evita MAX e MIN colarem por ruído // Histerese em % (muito importante para não ficar abrindo/fechando tremendo) const int FEIXE_LIGA_PCT = 70; // acima disso considera "laser chegou" const int FEIXE_DESL_PCT = 30; // abaixo disso considera "laser interrompido" /* ========================= APRENDIZADO DE MIN/MAX - O código vai "aprender" MAX e MIN observando o sensor. - Como seu sistema é binário (laser OK / laser bloqueado), com o uso real ele converge rapidamente. ========================= */ const unsigned long JANELA_APRENDIZADO_MS = 8000; // primeiros 8s aprende mais agressivo /* ========================= ESTADOS DO PORTÃO ========================= */ enum EstadoPortao { PORTAO_FECHADO, PORTAO_ABERTO, AGUARDANDO_FECHAR }; EstadoPortao estado = PORTAO_FECHADO; /* ========================= VARIÁVEIS GLOBAIS ========================= */ Servo servoPortao; int ldrMin = 4095; // MIN (sem laser) -> começa alto, vai caindo int ldrMax = 0; // MAX (com laser) -> começa baixo, vai subindo bool feixeOK = false; // estado estável do feixe (com histerese) unsigned long tInicio = 0; unsigned long tInicioFechar = 0; /* ========================= FUNÇÕES DO PORTÃO ========================= */ void abrePortao() { Serial.println("[PORTAO] Abrindo (servo -> Y)..."); servoPortao.write(SERVO_ABERTO); estado = PORTAO_ABERTO; } void fechaPortao() { Serial.println("[PORTAO] Fechando (servo -> X)..."); servoPortao.write(SERVO_FECHADO); estado = PORTAO_FECHADO; } /* ========================= LEITURA COM MÉDIA ========================= */ int lerLDR() { long soma = 0; for (int i = 0; i < AMOSTRAS_MEDIA; i++) { soma += analogRead(PIN_LDR); delay(2); } return (int)(soma / AMOSTRAS_MEDIA); } /* ========================= NORMALIZA PARA 0?100% 0% = ldrMin 100% = ldrMax ========================= */ int normalizarPct(int leitura) { int minV = ldrMin; int maxV = ldrMax; // segurança: se ainda não aprendeu nada (min ~ max), evita divisão por zero if (maxV <= minV + MARGEM_MINMAX) return 0; long num = (long)(leitura - minV) * 100L; long den = (long)(maxV - minV); int pct = (int)(num / den); if (pct < 0) pct = 0; if (pct > 100) pct = 100; return pct; } /* ========================= ATUALIZA MIN/MAX (aprendizado) - Durante os primeiros segundos: aprende mais rápido - Depois: aprende mais "devagar" (mas ainda acompanha pequenas mudanças) ========================= */ void atualizarMinMax(int leitura, unsigned long agora) { bool emAprendizado = (agora - tInicio) < JANELA_APRENDIZADO_MS; // No começo: captura extremos com mais agressividade if (emAprendizado) { if (leitura < ldrMin) ldrMin = leitura; if (leitura > ldrMax) ldrMax = leitura; } else { // Depois: ajusta com cautela (evita "andar" demais com ruído) // Ainda assim permite adaptar um pouco se ambiente mudar. if (leitura < ldrMin) ldrMin = leitura; if (leitura > ldrMax) ldrMax = leitura; // Opcional: "puxar" lentamente para dentro (anti-deriva), bem sutil // (mantém a escala saudável ao longo do tempo) ldrMin += 0; // deixe 0 se não quiser ldrMax -= 0; // deixe 0 se não quiser } // evita min/max inverterem por ruído if (ldrMax < ldrMin + MARGEM_MINMAX) { ldrMax = ldrMin + MARGEM_MINMAX; } } /* ========================= ATUALIZA ESTADO DO FEIXE COM HISTERSE - Se ainda está OFF, só liga ao passar de FEIXE_LIGA_PCT - Se ainda está ON, só desliga ao cair abaixo de FEIXE_DESL_PCT ========================= */ bool calcularFeixeOK(int pct, bool atual) { if (!atual) { // estava "interrompido", só vira OK com % alto return (pct >= FEIXE_LIGA_PCT); } else { // estava OK, só vira interrompido com % baixo return (pct > FEIXE_DESL_PCT); } } void setup() { Serial.begin(115200); delay(200); Serial.println("\n=== GARAGEM: Laser (MAX) / Sem Laser (MIN) -> Escala 0?100% ==="); analogReadResolution(12); // 0..4095 (ESP32) servoPortao.setPeriodHertz(50); servoPortao.attach(PIN_SERVO, 500, 2400); // começa fechado fechaPortao(); tInicio = millis(); Serial.println("[INFO] Aprendizado inicial de MIN/MAX ativo por ~8s."); Serial.println("[INFO] Mostrando logs: RAW | MIN | MAX | PCT | FEIXE | ESTADO"); } void loop() { unsigned long agora = millis(); // 1) lê LDR int raw = lerLDR(); // 2) atualiza MIN/MAX (regra: max=laser, min=sem laser) atualizarMinMax(raw, agora); // 3) cria escala 0?100% int pct = normalizarPct(raw); // 4) decide feixe OK com histerese bool feixeNovo = calcularFeixeOK(pct, feixeOK); // 5) se mudou, loga e reage if (feixeNovo != feixeOK) { feixeOK = feixeNovo; Serial.print("[FEIXE] Mudou para: "); Serial.print(feixeOK ? "OK (laser chegou)" : "INTERROMPIDO (sem laser)"); Serial.print(" | RAW="); Serial.print(raw); Serial.print(" | MIN="); Serial.print(ldrMin); Serial.print(" | MAX="); Serial.print(ldrMax); Serial.print(" | PCT="); Serial.println(pct); // Reações do portão if (!feixeOK) { // Interrompeu -> abre na hora if (estado != PORTAO_ABERTO) { abrePortao(); } // Se estava aguardando fechar, cancela if (estado == AGUARDANDO_FECHAR) { Serial.println("[TIMER] Cancelado (feixe caiu de novo)."); estado = PORTAO_ABERTO; } } else { // Voltou -> se está aberto, começa contagem para fechar if (estado == PORTAO_ABERTO) { estado = AGUARDANDO_FECHAR; tInicioFechar = agora; Serial.println("[TIMER] Feixe voltou. Contando 5s para fechar..."); } } } // 6) se aguardando, fecha após 5s com feixe ainda OK if (estado == AGUARDANDO_FECHAR) { if ((agora - tInicioFechar) >= TEMPO_PARA_FECHAR_MS) { if (feixeOK) { Serial.println("[TIMER] 5s completos com feixe OK -> FECHANDO."); fechaPortao(); } else { Serial.println("[TIMER] 5s completos, mas feixe não OK -> não fecha."); estado = PORTAO_ABERTO; } } } // 7) log contínuo (útil pra você ver a escala funcionando) static unsigned long tLog = 0; if (agora - tLog > 250) { tLog = agora; Serial.print("[LOG] RAW="); Serial.print(raw); Serial.print(" | MIN="); Serial.print(ldrMin); Serial.print(" | MAX="); Serial.print(ldrMax); Serial.print(" | PCT="); Serial.print(pct); Serial.print(" | FEIXE="); Serial.print(feixeOK ? "OK" : "OFF"); Serial.print(" | ESTADO="); if (estado == PORTAO_FECHADO) Serial.println("FECHADO"); else if (estado == PORTAO_ABERTO) Serial.println("ABERTO"); else Serial.println("AGUARDANDO_FECHAR"); } delay(LOOP_DELAY_MS); }

Testes e calibração

Durante os testes, observar no Monitor Serial os valores:

RAW | MIN | MAX | PCT | FEIXE | ESTADO

Verifique se:
- Com laser alinhado, o PCT fica próximo de 100%
- Com feixe interrompido, o PCT fica próximo de 0%

Caso necessário, ajustar os valores de FEIXE_LIGA_PCT e FEIXE_DESL_PCT.

Conclusão

Este projeto demonstra como transformar um simples LDR em uma barreira óptica robusta utilizando filtro mecânico combinado com tratamento por software (escala + histerese). A combinação garante estabilidade e confiabilidade mesmo em ambientes com iluminação variável.

Uma dica, a foto acima mostra que usei um arame para travar o eixo do servo a alavanca da garagem, voce pode usar o arame (era um clipes de papel grande), um elastico ambos funcionaram bem. outro detalhe, depois de montado, voce pode colar um pequeno cubo de teste 1x1x1 cm sobre o eixo de articulacao, para evitar que o portão escape da alavanca">