Projeto de casa inteligente com Arduino: maquete, sensores, código e app

Um projeto de casa inteligente com Arduino transforma as luzes, a porta, a janela e os alarmes de uma maquete em um sistema que funciona sozinho com sensores, e, se você quiser, tudo isso também pode ser controlado pelo celular. Não é à toa que ele é um dos projetos escolares mais populares. Uma luz de corredor que acende ao detectar movimento, um alarme que dispara quando vaza gás, uma ventoinha que liga quando esquenta e uma porta que abre com um cartão formam uma cópia pequena, mas funcional, de um sistema de casa inteligente de verdade. Com um Arduino Uno ou um ESP32, uns dez módulos e um fim de semana, você também consegue montar a sua.

Neste guia começamos pela planta da maquete: qual módulo vai em cada cômodo, para onde vai o orçamento, como planejar a alimentação e como distribuir os pinos. Depois montamos e testamos cada módulo, um por um, e escrevemos o sketch completo do Arduino que roda todos ao mesmo tempo sem usar delay(). Nas seções finais você vai aprender a controlar a casa pelo celular com um servidor web no ESP32 ou com o Blynk, a corrigir os erros mais comuns e a impressionar os avaliadores na apresentação da escola.

Como funciona um sistema de casa inteligente?

Toda casa inteligente funciona com o mesmo ciclo de três partes. Os sensores medem o ambiente: tem alguém se mexendo, está escuro, qual é a temperatura, há gás ou chama na cozinha, qual cartão foi aproximado da porta? O controlador, ou seja, o Arduino ou o ESP32, compara essas informações com regras: “se está escuro e há movimento, acenda a luz”, “se a temperatura passar de 28 °C, ligue a ventoinha”. Os atuadores executam a decisão: um relé liga a lâmpada e a ventoinha, um servo gira a porta e a janela, o buzzer toca e o display mostra o status. O controle pelo celular só acrescenta mais uma entrada a esse ciclo; desta vez, quem decide é o seu toque na tela, e não uma regra.

Planejando a maquete

Projete a maquete em torno da eletrônica; não tente enfiar a eletrônica depois. Uma base de cerca de 50×40 cm basta para dois ou três cômodos e uma entrada. Para as paredes, placa de espuma (foam board) de 5 mm ou placa de PVC expandido (como o Forex) se corta fácil com estilete; MDF de 3–4 mm é mais resistente, mas exige serra ou cortadora a laser. A escala 1:20 é um bom ponto de partida: um pé-direito de 2,6 m vira uma parede de 13 cm e uma porta de 90 cm fica com 4,5 cm de largura. Faça o telhado removível ou deixe a casa sem telhado; os avaliadores vão querer ver o interior dos cômodos.

• Sala técnica ou piso duplo: coloque o Arduino, a protoboard, o módulo relé e a entrada de alimentação em um compartimento nos fundos da casa ou sob um piso duplo de 3–4 cm de altura. Se você cobri-lo com acrílico transparente, o circuito fica protegido e visível ao mesmo tempo.
• Canaletas para os cabos: faça um furo de 6–8 mm embaixo de cada sensor e passe os cabos por baixo da base até a sala técnica. Em vez de emendar fios curtos, escolha desde o início fios de sensor compridos o bastante.
• Porta: prenda a porta na parede com uma dobradiça pequena ou fita e ligue o braço do SG90 à porta com um arame feito de clipe de papel. Cole o RC522 no lado de dentro da parede externa; o leitor normalmente lê o cartão através de uma placa de 5 mm também.
• Cozinha: em casas de verdade, o detector de gás natural (metano) fica perto do teto, porque ele é mais leve que o ar, e o de GLP (gás de botijão) fica perto do chão, porque o GLP é mais pesado; numa maquete, um ponto perto do teto serve. Aponte o sensor de chama para o fogão.
• Outros sensores: coloque o PIR em um canto que veja o caminho da entrada de lado, o LDR em uma parede externa ou janela onde ele não enxergue a luz da lâmpada, e o DHT11 longe da lâmpada e do corpo quente do MQ-2.

Lista de peças e custo

Os preços mudam com frequência conforme o vendedor e com o tempo, por isso não damos valores; a tabela mostra o peso de cada peça no orçamento. Os sensores e módulos são todos baratos sozinhos; a maior parte do orçamento vai para a placa, o LCD, a fonte e os materiais da maquete. Se você tem um kit Arduino para iniciantes, a placa, a protoboard, os fios, o LDR, o buzzer e muitas vezes um servo e um LCD já estão garantidos. Com orçamento apertado, dá para dispensar o LCD e o segundo servo: use o Monitor Serial no lugar do display e deixe a janela para uma etapa posterior. Um DHT22, mais preciso, no lugar do DHT11 custa um pouco mais, mas deixa suas medições mais convincentes na apresentação.

Plano de alimentação: por que uma fonte de 5 V separada?

Nas maquetes de casa inteligente, quase toda reclamação do tipo “reinicia de vez em quando”, “o servo treme” ou “aparecem caracteres estranhos no LCD” tem a ver com alimentação. A porta USB de um computador fornece cerca de 500 mA, e quando a placa roda pela USB o pino 5V do Uno também fica atrás desse limite. Some os valores abaixo e você verá que a corrente total passa fácil de 1 A quando os dois servos se movem ao mesmo tempo.

Plano de pinos: Arduino Uno e ESP32

Essa quantidade de módulos quase esgota os pinos do Uno, então é preciso planejá-los desde o início. O RC522 usa SPI de hardware, por isso as linhas MOSI, MISO e SCK ficam presas a D11, D12 e D13. O LCD usa só A4 e A5 via I2C, e é por isso que escolhemos um display com módulo I2C em vez de um LCD paralelo. Os pinos analógicos também funcionam como digitais quando necessário, e é assim que conseguimos ligar o servo da janela no A2. Deixe D0 e D1 livres: essa linha serial é usada quando você carrega o código e quando lê os números dos cartões no Monitor Serial. Você pode ver a disposição dos pinos da sua placa na ferramenta Pinagem.

Montagem passo a passo

1. Monte a estrutura da maquete e prepare as posições dos módulos e os furos dos cabos; instale a eletrônica por último.
2. Monte a linha de alimentação: ligue a fonte de 5 V nos barramentos de alimentação da protoboard, una o GND da fonte ao GND do Arduino e confira os 5 V com um multímetro.
3. Ligue o LCD I2C e escreva um texto nele. Se não encontrar o endereço do display, use o sketch scanner do artigo LCD I2C.
4. Adicione os sensores um de cada vez: DHT11, LDR, PIR, MQ-2 e sensor de chama. Teste cada um com um sketch curto no Monitor Serial e anote as leituras com ar limpo, no escuro e na luz.
5. Adicione os atuadores: primeiro teste os relés sem carga, observando o clique e o LED deles, depois os servos com alimentação externa e, por fim, ligue o RC522. Leia seus cartões e anote os números.
6. Carregue o sketch principal e ajuste os limites GAS_LIMIT, DARK_LIMIT e FAN_ON com base nas suas anotações.
7. Prenda os fios com cola quente e etiquetas, depois deixe o sistema ligado por meia hora e observe se há reinícios, superaquecimento ou alarmes falsos.

Luz automática com PIR e LDR

O sensor PIR HC-SR501 detecta mudanças na radiação infravermelha emitida pelo corpo humano e coloca a saída em HIGH quando vê movimento. Só com o PIR, a lâmpada acenderia também de dia, então nossa regra tem duas condições: acender se houver movimento e estiver escuro. O LDR é ligado como divisor de tensão com um resistor de 10 kΩ (5V → LDR → A1 → 10 kΩ → GND), e a leitura em A1 cai conforme escurece. O código guarda o horário do último movimento e apaga a lâmpada após 20 segundos sem novo movimento; enquanto alguém estiver andando por ali, o temporizador recomeça a cada vez. Coloque o jumper do sensor em H (redisparo) e o potenciômetro Tx no tempo mais curto, e deixe o código decidir o tempo. Mais detalhes nos artigos sensor de movimento PIR e sensor de luz LDR.

Alarme de gás e incêndio

Dentro do MQ-2 há uma camada de dióxido de estanho mantida quente por um aquecedor; GLP, metano, butano, hidrogênio, álcool e fumaça mudam a resistência dessa camada. O pino AO do módulo fornece uma tensão que sobe conforme o nível de gás aumenta. O sensor precisa aquecer toda vez que é ligado, por isso o código ignora alarmes de gás nos primeiros 60 segundos. O sensor de chama detecta a luz infravermelha de 760–1100 nm emitida pelo fogo; na maioria dos módulos, a saída DO vai para LOW e um segundo LED da placa acende quando uma chama é vista, mas sempre teste o seu módulo com um isqueiro mantido a distância. Quando o gás é detectado, o alarme toca e a janela abre para ventilar; quando uma chama é detectada, a janela continua fechada, porque ar fresco alimenta o fogo. O ajuste do limite e os outros sensores MQ estão no artigo sensor de gás MQ-2.

Temperatura, umidade e ventoinha automática

O DHT11 mede temperatura de 0 a 50 °C com precisão de ±2 °C e umidade de 20 a 90% com precisão de ±5%, e pode ser lido no máximo uma vez por segundo; o código o lê a cada dois segundos. Em vez de um único limite para a ventoinha, usamos histerese: a ventoinha liga em 28 °C, mas só desliga quando a temperatura cai para 26 °C. Com um único limite, o relé ficaria clicando enquanto a temperatura oscilasse entre 27 e 28 °C, desgastando ele mesmo e a ventoinha. Se o sensor falhar numa leitura e retornar “nan”, o código pula essa medição e mantém o último valor válido. Para medições mais precisas, o DHT22 funciona com o mesmo código; basta escrever DHT22 no lugar de DHT11. Mais detalhes no artigo sensor de temperatura e umidade DHT11.

Porta com cartão RFID e servo

O RC522 lê cartões e chaveiros MIFARE de 13,56 MHz a 3–5 cm de distância. Cada cartão tem seu próprio número de identificação (UID), e o código compara o UID lido com uma lista de cartões autorizados. Se houver correspondência, o servo gira a porta até 90 graus, você ouve um bipe curto e o LCD mostra “Hos geldin!” (“Bem-vindo!” em turco); 5 segundos depois, a porta se fecha sozinha. Um cartão desconhecido recebe um bipe longo. Para descobrir o UID dos seus cartões, carregue o código, abra o Monitor Serial em 9600 baud e aproxime um cartão: você verá uma linha como “UID: A1 B2 C3 D4”. Escreva esses bytes na lista CARDS no formato 0xA1, acrescentando um zero à esquerda em qualquer byte mostrado com um só dígito (0x05 em vez de 5). Uma fechadura que só verifica o UID serve para aprender, mas não dá segurança de verdade; explicamos o motivo no artigo leitor RFID.

Janela e cortina

Para a janela, basta um segundo SG90: ligue uma pequena janela de acrílico com dobradiça ao braço do servo com um arame, sendo 0 grau fechada e 90 graus aberta. Chamar write(0) antes de attach() impede que o servo pule para 90 graus ao ligar e bata a janela. Uma cortina precisa de mais curso: você enrola o tecido em uma vareta fina e gira a vareta. Um motor de passo 28BYJ-48 com driver ULN2003 é silencioso e preciso para isso, mas precisa de 4 pinos; como o Uno não tem mais nenhum livre, faz sentido deixar a cortina para a versão com ESP32 ou para um Arduino Mega. Se tiver que ser um pino só, um servo de rotação contínua FS90R também funciona, mas como ele não sabe a própria posição, você abre e fecha a cortina pelo tempo. Adicionar um sensor de chuva para fechar a janela automaticamente quando chove também é uma boa extensão.

Lâmpada e ventoinha com relé

Um pino do Arduino só consegue fornecer com segurança cerca de 20 mA (o limite absoluto é 40 mA), enquanto uma ventoinha ou lâmpada precisa de muito mais. Por isso um módulo relé fica no meio: o sinal no pino IN aciona um eletroímã que fecha contatos em um circuito separado. Ligue a carga nos terminais COM e NO, para que a lâmpada fique apagada enquanto o Arduino estiver desligado ou reiniciando. A maioria desses módulos é ativa em LOW, ou seja, o relé liga quando você escreve LOW; é para isso que servem as constantes RELAY_ON e RELAY_OFF no código. No setup(), o código escreve HIGH antes de configurar o pino como saída, para que o relé não clique nem por um instante quando o Arduino inicia. Usamos histerese para a ventoinha não ligar e desligar com frequência demais, enquanto a lâmpada fica acesa até o temporizador do PIR acabar.

O sketch completo (Arduino Uno)

A regra mais importante no código de uma casa inteligente é que nenhum módulo espera pelo outro. Se você mantivesse a porta aberta por 5 segundos com delay(5000), o alarme de gás não funcionaria e o PIR não seria lido durante esse tempo. Por isso colocamos cada módulo em uma função própria, e o loop() chama essas funções uma depois da outra centenas de vezes por segundo. Tudo que envolve tempo é medido com millis(), e o estado de cada módulo fica em variáveis como lightOn, fanOn, doorOpen e alarmOn. Todas as configurações ficam no topo do código como constantes, então você não precisa vasculhar o código para mudar um limite. A lógica por trás dessa abordagem está no artigo millis() ou delay(). Para compilar o código, instale pelo Gerenciador de Bibliotecas a biblioteca MFRC522, a DHT sensor library da Adafruit e a LiquidCrystal I2C de Frank de Brabander, e instale todas as dependências quando for perguntado. Servo, SPI e Wire já vêm com o Arduino IDE.

1#include <SPI.h>
2#include <MFRC522.h>
3#include <Servo.h>
4#include <DHT.h>
5#include <Wire.h>
6#include <LiquidCrystal_I2C.h>
7
8// Pinler / Pins
9const byte PIR_PIN = 2, FLAME_PIN = 3, DHT_PIN = 4, BUZZER_PIN = 5, DOOR_PIN = 6;
10const byte LAMP_RELAY = 7, FAN_RELAY = 8, RST_PIN = 9, SS_PIN = 10;
11const byte GAS_PIN = A0, LDR_PIN = A1, WINDOW_PIN = A2;
12
13// Ayarlar / Settings
14const byte RELAY_ON = LOW, RELAY_OFF = HIGH;     // aktif LOW röle / active-LOW relay
15const byte FLAME_ACTIVE = LOW;                   // alev görünce DO LOW olur / DO goes LOW on flame
16const int GAS_LIMIT = 400;                       // temiz havaya göre ayarla / tune in clean air
17const int DARK_LIMIT = 300;                      // bunun altı karanlık / below this is dark
18const float FAN_ON = 28.0, FAN_OFF = 26.0;       // fan histerezisi (°C) / fan hysteresis (°C)
19const unsigned long LIGHT_MS = 20000;            // son hareketten sonra ışık / light after last motion
20const unsigned long DOOR_MS = 5000;              // kapı açık kalma süresi / door open time
21const unsigned long WARMUP_MS = 60000;           // MQ-2 ve PIR ısınması / MQ-2 and PIR warm-up
22
23const byte CARDS[][4] = {                        // yetkili kart UID'leri / authorised card UIDs
24  {0xA1, 0xB2, 0xC3, 0xD4},
25  {0x12, 0x34, 0x56, 0x78}
26};
27
28MFRC522 rfid(SS_PIN, RST_PIN);
29Servo door, window;
30DHT dht(DHT_PIN, DHT11);
31LiquidCrystal_I2C lcd(0x27, 16, 2);
32
33float tempC = 0, hum = 0;
34int gas = 0;
35bool lightOn = false, fanOn = false, doorOpen = false, alarmOn = false;
36unsigned long lastMotion = 0, doorAt = 0, lastDht = 0, lastLcd = 0, beepUntil = 0;
37
38void setup() {
39  Serial.begin(9600);
40  digitalWrite(LAMP_RELAY, RELAY_OFF); pinMode(LAMP_RELAY, OUTPUT);  // açılışta kapalı / off at boot
41  digitalWrite(FAN_RELAY, RELAY_OFF);  pinMode(FAN_RELAY, OUTPUT);
42  pinMode(PIR_PIN, INPUT);
43  pinMode(FLAME_PIN, INPUT);
44  pinMode(BUZZER_PIN, OUTPUT);
45  door.write(0);   door.attach(DOOR_PIN);        // önce açı, sonra attach / angle first, then attach
46  window.write(0); window.attach(WINDOW_PIN);
47  dht.begin();
48  SPI.begin();
49  rfid.PCD_Init();
50  lcd.init();
51  lcd.backlight();
52  lcd.print(F("BlueGrays Ev"));
53}
54
55void loop() {
56  unsigned long now = millis();
57  handleLight(now);
58  handleClimate(now);
59  handleSafety(now);
60  handleDoor(now);
61  bool beep = (long)(beepUntil - now) > 0;
62  digitalWrite(BUZZER_PIN, beep || (alarmOn && (now / 250) % 2));   // alarmda kesik bip / pulsed beep on alarm
63  updateLcd(now);
64}
65
66// 1) Hareketle ışık / motion light
67void handleLight(unsigned long now) {
68  if (now < WARMUP_MS) return;                   // PIR ısınıyor / PIR warming up
69  if (digitalRead(PIR_PIN) == HIGH) {
70    lastMotion = now;
71    if (analogRead(LDR_PIN) < DARK_LIMIT) lightOn = true;   // yalnız karanlıkta yak / only when dark
72  }
73  if (lightOn && now - lastMotion > LIGHT_MS) lightOn = false;
74  digitalWrite(LAMP_RELAY, lightOn ? RELAY_ON : RELAY_OFF);
75}
76
77// 2) Sıcaklık ve fan / temperature and fan
78void handleClimate(unsigned long now) {
79  if (now - lastDht < 2000) return;              // DHT11'i sık okuma / don't read DHT11 too often
80  lastDht = now;
81  float t = dht.readTemperature();
82  float h = dht.readHumidity();
83  if (isnan(t) || isnan(h)) return;              // okuma hatası / read error
84  tempC = t;
85  hum = h;
86  if (tempC >= FAN_ON) fanOn = true;
87  if (tempC <= FAN_OFF) fanOn = false;
88  digitalWrite(FAN_RELAY, fanOn ? RELAY_ON : RELAY_OFF);
89}
90
91// 3) Gaz ve yangın / gas and fire
92void handleSafety(unsigned long now) {
93  gas = analogRead(GAS_PIN);
94  bool gasAlarm = now > WARMUP_MS && gas > GAS_LIMIT;
95  bool fire = digitalRead(FLAME_PIN) == FLAME_ACTIVE;
96  alarmOn = gasAlarm || fire;
97  window.write(gasAlarm && !fire ? 90 : 0);      // gazda aç, yangında kapalı tut / open on gas, shut on fire
98}
99
100// 4) RFID kapı / RFID door
101void handleDoor(unsigned long now) {
102  if (doorOpen && now - doorAt > DOOR_MS) {
103    door.write(0);                               // süre dolunca kapat / close when time is up
104    doorOpen = false;
105  }
106  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
107  Serial.print(F("UID:"));                       // yeni kartın UID'sini öğren / learn a new card's UID
108  for (byte i = 0; i < rfid.uid.size; i++) {
109    Serial.print(' ');
110    Serial.print(rfid.uid.uidByte[i], HEX);
111  }
112  Serial.println();
113  if (isAllowed(rfid.uid.uidByte)) {
114    door.write(90);
115    doorOpen = true;
116    doorAt = now;
117    beepUntil = now + 100;                       // kısa bip: hoş geldin / short beep: welcome
118  } else {
119    beepUntil = now + 800;                       // uzun bip: yetkisiz kart / long beep: unknown card
120  }
121  rfid.PICC_HaltA();
122}
123
124bool isAllowed(const byte *uid) {
125  for (byte i = 0; i < sizeof(CARDS) / 4; i++) {
126    if (memcmp(uid, CARDS[i], 4) == 0) return true;
127  }
128  return false;
129}
130
131// 5) Ekran / display
132void updateLcd(unsigned long now) {
133  if (now - lastLcd < 1000) return;
134  lastLcd = now;
135  lcd.setCursor(0, 0);
136  lcd.print(F("T:"));
137  lcd.print(tempC, 0);
138  lcd.print(F("C Nem:%"));
139  lcd.print(hum, 0);
140  lcd.print(F("   "));
141  lcd.setCursor(0, 1);
142  if (alarmOn) {
143    lcd.print(F("!! ALARM !!     "));
144  } else if (doorOpen) {
145    lcd.print(F("Hos geldin!     "));
146  } else {
147    lcd.print(F("Gaz:"));
148    lcd.print(gas);
149    lcd.print(F("        "));
150  }
151}

Depois de compilado, este código usa cerca de 38% da memória de programa do Uno e 28% da RAM, então ainda sobra memória, mas entre os pinos só o A3 continua livre. Você pode ligar um botão ou um sensor de chuva no A3; para qualquer coisa além disso, vai precisar passar para um Arduino Mega ou um ESP32. Colocar textos fixos dentro de F() é o jeito mais fácil de manter o uso de RAM baixo.

Controle pelo celular: servidor web no ESP32

O Uno não tem Wi-Fi; o jeito mais fácil de controlar a casa inteligente pelo celular é trocar o cérebro por um ESP32. O código abaixo conecta o ESP32 à rede da sua casa e inicia um pequeno servidor web. Com o celular na mesma rede Wi-Fi, abra no navegador o endereço IP mostrado no Monitor Serial e você verá quatro botões grandes para a lâmpada, a ventoinha, a porta e a janela, além da temperatura, da umidade e da leitura de gás atuais; a página se atualiza sozinha a cada 10 segundos. Cada botão envia ao ESP32 uma requisição curta dizendo qual aparelho alternar; o ESP32 muda o estado e redireciona você de volta para a página principal. Para os servos, instale a biblioteca ESP32Servo pelo Gerenciador de Bibliotecas, porque a biblioteca Servo padrão não funciona no ESP32.

1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4#include <DHT.h>
5
6const char* ssid = "AgAdi";                 // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123";          // Wi-Fi şifren / your Wi-Fi password
8
9const int LAMP_RELAY = 26, FAN_RELAY = 27;
10const int DOOR_PIN = 32, WINDOW_PIN = 33;
11const int DHT_PIN = 13, GAS_PIN = 34;       // GPIO 34: ADC1, bölücüyle / ADC1, through a divider
12const int RELAY_ON = LOW, RELAY_OFF = HIGH; // aktif LOW röle / active-LOW relay
13
14WebServer server(80);
15Servo door, window;
16DHT dht(DHT_PIN, DHT11);
17
18bool lamp = false, fan = false, doorOpen = false, windowOpen = false;
19float tempC = NAN, hum = NAN;
20unsigned long lastDht = 0;
21
22void apply() {                              // durumu donanıma uygula / push the state to the hardware
23  digitalWrite(LAMP_RELAY, lamp ? RELAY_ON : RELAY_OFF);
24  digitalWrite(FAN_RELAY, fan ? RELAY_ON : RELAY_OFF);
25  door.write(doorOpen ? 90 : 0);
26  window.write(windowOpen ? 90 : 0);
27}
28
29String button(const char* id, const char* label, bool on) {
30  return String("<a class='b ") + (on ? "on" : "off") + "' href='/set?d=" + id +
31         "&v=" + (on ? "0" : "1") + "'>" + label + (on ? ": ON" : ": OFF") + "</a>";
32}
33
34void handleRoot() {
35  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
36                "<meta name='viewport' content='width=device-width,initial-scale=1'>"
37                "<meta http-equiv='refresh' content='10'><title>BlueGrays Ev</title>"
38                "<style>body{font-family:sans-serif;text-align:center}"
39                ".b{display:block;margin:12px auto;padding:18px;max-width:320px;border-radius:10px;"
40                "color:#fff;text-decoration:none;font-size:20px}"
41                ".on{background:#2e7d32}.off{background:#607d8b}</style></head><body>"
42                "<h2>BlueGrays Akıllı Ev</h2>";
43  html += "<p>" + String(tempC, 1) + " °C | %" + String(hum, 0) +
44          " | Gaz/Gas: " + String(analogRead(GAS_PIN)) + "</p>";
45  html += button("lamp", "Lamba / Lamp", lamp);
46  html += button("fan", "Fan", fan);
47  html += button("door", "Kapı / Door", doorOpen);
48  html += button("window", "Pencere / Window", windowOpen);
49  html += "</body></html>";
50  server.send(200, "text/html", html);
51}
52
53void handleSet() {                          // /set?d=lamp&v=1
54  String d = server.arg("d");
55  bool v = server.arg("v") == "1";
56  if (d == "lamp") lamp = v;
57  else if (d == "fan") fan = v;
58  else if (d == "door") doorOpen = v;
59  else if (d == "window") windowOpen = v;
60  apply();
61  server.sendHeader("Location", "/");       // ana sayfaya dön / back to the main page
62  server.send(303);
63}
64
65void setup() {
66  Serial.begin(115200);
67  door.attach(DOOR_PIN, 500, 2400);
68  window.attach(WINDOW_PIN, 500, 2400);
69  pinMode(LAMP_RELAY, OUTPUT);
70  pinMode(FAN_RELAY, OUTPUT);
71  apply();                                  // her şey kapalı başlar / everything starts off
72  dht.begin();
73  WiFi.begin(ssid, password);
74  while (WiFi.status() != WL_CONNECTED) {
75    delay(500);
76    Serial.print('.');
77  }
78  Serial.println();
79  Serial.println(WiFi.localIP());           // bu adresi telefonda aç / open this address on your phone
80  server.on("/", handleRoot);
81  server.on("/set", handleSet);
82  server.begin();
83}
84
85void loop() {
86  server.handleClient();
87  if (millis() - lastDht > 2000) {          // 2 sn'de bir ölç / measure every 2 s
88    lastDht = millis();
89    float t = dht.readTemperature();
90    float h = dht.readHumidity();
91    if (!isnan(t) && !isnan(h)) {
92      tempC = t;
93      hum = h;
94    }
95  }
96}

Este código inclui só as partes que você controla a distância. Você também pode trazer para cá as funções handleLight(), handleSafety() e handleDoor() do sketch do Uno: mude os números dos pinos conforme a coluna do ESP32 na tabela, use ESP32Servo no lugar de Servo e meça de novo os limites GAS_LIMIT e DARK_LIMIT, porque o ADC do ESP32 retorna valores de 0 a 4095. A página não tem senha, então qualquer pessoa na rede da sua casa poderia abrir a porta; adicionar uma senha simples com a função authenticate() da biblioteca WebServer é um bom hábito. Para um painel que se atualiza em tempo real, veja o artigo WebSocket no ESP32.

Controle de qualquer lugar com o Blynk

O servidor web do ESP32 só pode ser acessado da mesma rede. Se você também quer controlar de fora de casa pelos dados móveis, uma plataforma em nuvem como o Blynk IoT facilita: você monta a interface arrastando e soltando no app do celular, e o ESP32 se conecta ao servidor do Blynk. Crie um template no Blynk.Cloud, adicione três datastreams chamados V0 (integer, 0–1, lâmpada), V1 (double, temperatura) e V2 (double, umidade), adicione um dispositivo e cole no topo do código o Template ID, o Template Name e o Auth Token que você receber. No app, basta ligar um Switch ao V0 e um Gauge a cada um, V1 e V2. O plano grátis limita o número de dispositivos, de datastreams e de mensagens por mês, e é por isso que enviamos os dados dos sensores a cada cinco segundos, e não a cada segundo. A configuração completa está no guia Blynk IoT com ESP32.

1#define BLYNK_TEMPLATE_ID "TMPLxxxxxxx"     // Blynk konsolundan kopyala / copy from the Blynk console
2#define BLYNK_TEMPLATE_NAME "Akilli Ev"
3#define BLYNK_AUTH_TOKEN "TokenBuraya"
4
5#include <WiFi.h>
6#include <BlynkSimpleEsp32.h>
7#include <DHT.h>
8
9const int LAMP_RELAY = 26;                  // aktif LOW röle / active-LOW relay
10DHT dht(13, DHT11);
11BlynkTimer timer;
12
13BLYNK_WRITE(V0) {                           // uygulamadaki anahtar / switch widget in the app
14  digitalWrite(LAMP_RELAY, param.asInt() ? LOW : HIGH);
15}
16
17BLYNK_CONNECTED() {
18  Blynk.syncVirtual(V0);                    // bağlanınca son durumu al / restore the last state
19}
20
21void sendSensors() {
22  float t = dht.readTemperature();
23  float h = dht.readHumidity();
24  if (isnan(t) || isnan(h)) return;
25  Blynk.virtualWrite(V1, t);                // sıcaklık / temperature
26  Blynk.virtualWrite(V2, h);                // nem / humidity
27}
28
29void setup() {
30  pinMode(LAMP_RELAY, OUTPUT);
31  digitalWrite(LAMP_RELAY, HIGH);           // açılışta kapalı / off at boot
32  dht.begin();
33  Blynk.begin(BLYNK_AUTH_TOKEN, "AgAdi", "Sifre123");
34  timer.setInterval(5000L, sendSensors);    // 5 sn'de bir: mesaj kotasını korur / every 5 s saves quota
35}
36
37void loop() {
38  Blynk.run();
39  timer.run();
40}

Qual método de controle escolher?

Para uma apresentação na escola, o servidor web no ESP32 é a escolha mais segura: ele não depende da internet nem de nuvem e funciona com a própria rede mesmo que não haja Wi-Fi no local. Se você quer continuar com o Uno e só adicionar Bluetooth, pode criar seu próprio app Android com o App Inventor; mas como o Uno não tem mais pinos livres, você vai ter que abrir mão do LCD ou do servo da janela para dar lugar ao HC-05. Você pode receber uma mensagem no celular quando o alarme disparar com um bot do Telegram no ESP32 e ligar a casa a aparelhos reais com MQTT e Home Assistant.

Casa inteligente com o Raspberry Pi Pico

Você também pode montar o mesmo sistema em MicroPython com um Raspberry Pi Pico, e o Pico W, que tem Wi-Fi, pode ser controlado pelo celular assim como o ESP32 (veja o servidor web no Pico W). Como o Pico funciona em 3,3 V, as regras do ESP32 valem aqui também: alimente o divisor do LDR pelo 3V3, reduza as saídas analógicas de 5 V com um divisor e escolha um módulo relé que possa ser acionado com 3,3 V. As únicas entradas analógicas são GP26, GP27 e GP28. O código abaixo é a versão em MicroPython do módulo de luz ativada por movimento:

1from machine import Pin, ADC
2import time
3
4pir = Pin(15, Pin.IN)                  # PIR OUT (3,3 V çıkış / 3.3 V output)
5ldr = ADC(26)                          # GP26: bölücü 3V3'ten / divider fed from 3V3
6relay = Pin(14, Pin.OUT, value=1)      # aktif LOW röle, kapalı başla / active-LOW relay, start off
7
8LIGHT_MS = 20000                       # son hareketten sonra ışık / light after last motion
9DARK = 20000                           # bunun altı karanlık / below this is dark
10last = time.ticks_ms()
11on = False
12
13while True:
14    now = time.ticks_ms()
15    if pir.value():
16        last = now
17        if ldr.read_u16() < DARK:      # yalnız karanlıkta yak / only when dark
18            on = True
19    if on and time.ticks_diff(now, last) > LIGHT_MS:
20        on = False
21    relay.value(0 if on else 1)
22    time.sleep_ms(50)

Dicas para a apresentação na escola

• Comece por um problema: descreva um problema real em uma frase, como “luzes esquecidas acesas em casa vazia, um vazamento de gás que ninguém percebe, idosos que perdem as chaves”, e depois mostre como sua maquete responde a ele.
• Prepare um diagrama de blocos: sensores à esquerda, o Arduino no meio e atuadores à direita; escreva as regras nas setas (“escuro + movimento → lâmpada”). Os avaliadores não vão ler seu código, mas vão lembrar desse diagrama.
• Roteirize uma demonstração ao vivo: passe o cartão e mostre a porta abrindo, acene na frente do PIR, aproxime do MQ-2 um algodão com álcool de limpeza (o álcool também aciona o sensor) e aqueça o DHT11 com os dedos. Mantenha cada demonstração em 10–20 segundos.
• Nada de chama aberta: não acenda isqueiro nem vela dentro de uma maquete de papelão. A maioria dos sensores de chama também reage à luz infravermelha de um controle remoto de TV mantido perto; teste isso antes e use na demonstração.
• Ajuste os limites para o ambiente: se no dia o local estiver a 22 °C, esperar 28 °C vai estragar a demonstração da ventoinha; ajuste FAN_ON 2–3 graus acima da temperatura ambiente para a ventoinha ligar quando você aquecer o sensor com os dedos.
• Meça e use números: por exemplo, registre quantos minutos por dia a lâmpada fica acesa com e sem o PIR e informe a economia em porcentagem. Um resultado com números é muito mais forte do que dizer “funciona”.
• Tenha um plano B: grave um vídeo do sistema funcionando, leve fios, um servo e uma fonte de reserva, e anote em um papel os números dos cartões e as configurações do Wi-Fi.
• Prepare-se para as perguntas dos avaliadores: para “Como funcionaria numa casa de verdade?”, tenha respostas curtas prontas sobre segurança com a rede elétrica, detectores certificados, segurança do RFID e o que a porta faz quando falta energia.

Erros comuns e como resolvê-los

Um projeto de casa inteligente com Arduino reúne em uma só montagem leitura de sensores, tomada de decisões, acionamento de motores e relés, planejamento da alimentação e controle sem fio, o que faz dele um ótimo tema tanto para aprender quanto para apresentar. Comece com um módulo, teste cada passo e faça o sistema crescer aos poucos. No app BlueGrays você encontra, passo a passo e com esquemas do circuito e código, os projetos de iluminação inteligente de escada, iluminação inteligente com PIR e LDR, alarme de chama e gás, fechadura RFID e servidor web no ESP32.