Termostato Digital com ESP32, Supabase e Cloudflare Pages: Projeto Passo a Passo

Introdução

Controlar a temperatura de um ambiente com precisão é uma das aplicações mais úteis e procuradas na eletrônica e na automação. Seja para manter estável a temperatura de uma chocadeira de ovos, controlar o aquecimento de um aquário, automatizar a refrigeração de uma cervejaria artesanal ou proteger equipamentos em um rack de servidores, um termostato confiável faz toda a diferença.

Neste projeto passo a passo, você vai aprender a construir um Termostato Digital IoT Profissional utilizando a placa microcontrolada ESP32 com relé integrado, o sensor de temperatura e umidade DHT22 (AM2302), o banco de dados em nuvem Supabase (PostgreSQL) e uma interface web moderna publicada no Cloudflare Pages.

Interface web de controle do termostato digital com telemetria em tempo real e controle de histerese

O grande diferencial deste projeto é sua arquitetura híbrida autônoma: mesmo que a sua conexão com a internet caia ou o Wi-Fi fique instável, o ESP32 continua medindo a temperatura, calculando a histerese e acionando o relé localmente na velocidade da luz. Quando o sinal de rede retorna, todas as leituras e parâmetros são automaticamente sincronizados com o painel web no seu celular ou computador!

O que você vai aprender neste guia:

Como ligar o sensor DHT22 e a carga elétrica no ESP32 com total segurança

Como instalar as ferramentas no computador (Python, PlatformIO e Git) mesmo sem experiência prévia

Como criar e configurar seu banco de dados gratuito no Supabase (com tabelas e regras de segurança)

Como compilar e gravar o código na placa ESP32 pela porta USB

Como conectar a placa na rede Wi-Fi da sua casa usando um Portal Captivo no celular

Como publicar o painel de controle na nuvem da Cloudflare de forma gratuita

Como funciona a histerese na prática para proteger compressores e resistências contra queima

Material utilizado: a placa utilizada neste projeto é a ESP32 Relay X1 (ROBOBUILDERS RB2557), acompanhada do sensor digital DHT22, disponíveis no catálogo da RoboBuilders.

Parte 1 — Hardware e Ligações Elétricas

Antes de mexer em código ou programas, vamos entender quais peças formam o termostato e como conectá-las corretamente na bancada.

1.1 Conhecendo os Componentes

Componente	Função Prática no Projeto
Placa ESP32 Relay (RB2557)	É o “cérebro” do sistema. Possui o processador dual-core ESP32 com Wi-Fi/Bluetooth e já traz na própria placa o circuito de acionamento do relé com isolamento.
Sensor DHT22 (AM2302)	Mede temperatura (de -40 °C a +80 °C com resolução de 0,1 °C) e umidade relativa do ar (de 0% a 100%) através de um único pino de dados digital.
Resistor de 10kΩ (Pull-up)	Mantém o pino de dados do DHT22 em nível alto estável quando o sensor não está transmitindo pulsos.
Relé de Potência Onboard	Funciona como um interruptor automático acionado pelo ESP32 (GPIO 16) capaz de ligar e desligar cargas de até 10A em 127V/220V AC.
Fonte de Alimentação 12V DC	Alimenta a placa ESP32 através dos bornes dedicados VIN (+) e GND (-).

1.2 Diagrama de Ligação Elétrica

O diagrama elétrico abaixo mostra todas as conexões necessárias. Observe que o circuito está dividido de forma limpa: a eletrônica de baixa tensão (DC) fica à esquerda e o circuito de potência da rede elétrica (AC) fica à direita, isolado pelo relé:

Diagrama de ligação elétrica do Termostato Digital IoT com ESP32 e DHT22

1.3 Tabela Detalhada de Conexões

Siga a tabela abaixo para fazer cada ligação sem margem de erro:

De onde sai o fio (Origem)	Para onde vai (Destino)	Cor Sugerida	Tipo de Sinal	Por que ligar assim?
Fonte 12V (+) Positivo	Borne VIN da placa	Vermelho	Alimentação DC	Alimenta a placa ESP32 (suporta de 7V a 30V DC).
Fonte 12V (-) Negativo / Terra	Borne GND da placa	Preto	Terra comum (0V)	Fecha o circuito de alimentação da eletrônica.
Pino 3V3 do ESP32	Pino 1 (VCC) do sensor DHT22	Laranja / Vermelho	Alimentação 3.3V	Fornece a tensão regulada ideal para o sensor.
Pino GND do ESP32	Pino 4 (GND) do sensor DHT22	Preto	Referência 0V	Aterramento do barramento de sensores.
Pino GPIO 4 do ESP32	Pino 2 (DATA) do sensor DHT22	Amarelo	Sinal Digital 1-Wire	Linha por onde o ESP32 lê os pulsos de temperatura.
Resistor de 10kΩ	Entre Pino 1 (VCC) e Pino 2 (DATA)	—	Resistor Pull-up	Garante sinal limpo e sem ruídos eletromagnéticos.
Pino 3 do DHT22	Deixar sem conexão	—	NC (Não conectado)	Pino nulo sem função interna no sensor DHT22.
Rede AC (Fio Fase - L)	Borne NO (Relé)	Marrom / Preto	Linha 127V ou 220V	A Fase da rede entra no contato Normalmente Aberto do relé.
Borne COM (Relé)	Terminal 1 da Carga Climatizadora	Vermelho	Linha Chaveada	Quando o relé liga, a Fase passa para a carga.
Rede AC (Fio Neutro - N)	Terminal 2 da Carga Climatizadora	Azul Claro	Retorno Neutro	O Neutro da rede vai direto para a carga, fechando o circuito.
Borne NC (Relé)	Deixar sem conexão	—	Desconectado	Borne livre (não utilizado neste projeto).

⚠️ Atenções Importantes de Segurança:

Alimente o sensor DHT22 estritamente no pino 3.3V! Nunca ligue o VCC do sensor nos 5V ou no VIN de 12V. O ESP32 trabalha com lógica de 3.3V nas GPIOs; se receber pulsos de 5V na GPIO 4, a porta do microcontrolador será danificada.

Cuidado com a Rede Elétrica AC (127V/220V): Sempre desligue o disjuntor geral antes de manusear os fios que vão aos bornes do relé e à tomada da carga. Isole bem todas as emendas com fita isolante ou conectores do tipo sindal/wago.

Parte 2 — Instalando as Ferramentas no Computador

Para gravar o programa na placa ESP32, precisamos de três programas essenciais no computador:

Ferramenta	O que ela faz na prática?
Python	É o motor básico em cima do qual o compilador do PlatformIO é executado.
PlatformIO Core (CLI)	Compila o código C++, baixa automaticamente todas as bibliotecas necessárias e grava o binário no chip ESP32 pela porta USB.
Git	Baixa o projeto oficial direto do GitHub para a pasta do seu computador em um único comando.

Tudo acontece através do Terminal de Comandos. No Windows, abra o menu Iniciar, digite powershell ou cmd e pressione Enter. No Linux ou macOS, abra o aplicativo Terminal.

Passo 1 — Instalar o Python

Acesse o site oficial em python.org/downloads e baixe o instalador para o seu sistema.
Ao abrir o instalador, MUITO IMPORTANTE: marque a caixa “Add Python to PATH” na parte inferior da primeira tela antes de clicar em Install Now. Se esquecer essa caixinha, o terminal não conseguirá executar comandos do Python.
Conclua a instalação, feche o terminal aberto e abra um novo.
Digite no terminal para testar:
```
python --version
```
A resposta deve exibir algo como Python 3.11.x ou Python 3.12.x.

Passo 2 — Instalar o PlatformIO Core

O PlatformIO Core é a ferramenta que cuidará de toda a compilação do microcontrolador. Como ele é um pacote do Python, instalamos através do comando pip:

pip install platformio

(Se o comando pip não for reconhecido, use python -m pip install platformio).

Após a conclusão, confirme a instalação digitando:

pio --version

Aparecerá a versão instalada (ex.: PlatformIO Core, version 6.x.x).

Passo 3 — Instalar o Git

O Git serve para baixar os arquivos do projeto da internet para o seu computador de forma organizada:

Windows: baixe e instale o pacote oficial em git-scm.com mantendo as opções padrão do instalador.
Linux: execute sudo apt install git no terminal.
macOS: execute brew install git.

Confirme no terminal digitando:

git --version

Passo 4 — Descobrir a Porta Serial e Instalar o Driver CH340

Conecte a placa ESP32 ao computador usando um cabo USB de boa qualidade (que transmita dados, não apenas carregamento).

No Windows, clique com o botão direito no menu Iniciar e selecione Gerenciador de Dispositivos.
Abra a seção Portas (COM e LPT).
Se você ver um item chamado USB-SERIAL CH340 (COM3) ou similar (COM4, COM5, COM7), anote esse número de porta!
Se aparecer um ponto de exclamação amarelo ou o chip for listado em “Outros dispositivos”, você precisa instalar o driver oficial da fabricante chinesa WCH:
- Baixe o instalador no site oficial da WCH: CH341SER — Driver USB-Serial (ZIP).
- Extraia a pasta ZIP, execute o SETUP.EXE como Administrador e clique no botão INSTALL.
- Desconecte e reconecte o cabo USB da placa; a porta COM aparecerá limpa e sem erros.

Parte 3 — Baixando o Projeto e Entendendo a Estrutura

Com o ambiente pronto, vamos baixar os arquivos do repositório da RoboBuilders.

Abra o terminal e entre na pasta onde você prefere trabalhar (por exemplo, na Área de Trabalho):
```
cd Desktop
```

Baixe o repositório oficial com o Git:

git clone https://github.com/luanvieiramendes/ROBOBUILDERS.git
cd ROBOBUILDERS
cd "RB2557/Projeto - Termostato Digital Cloudfare Pages e Supabase"

💡 Nota: As aspas no comando cd acima são obrigatórias porque o nome da pasta contém espaços.

Vamos olhar como a pasta do projeto está organizada por dentro:

Projeto - Termostato Digital Cloudfare Pages e Supabase/
├── firmware/                       # CÓDIGO DA PLACA ESP32
│   ├── platformio.ini              # Configuração da placa, bibliotecas e velocidade USB
│   ├── include/
│   │   └── config.h                # Onde você coloca as credenciais do Supabase e pinos
│   └── src/
│       └── main.cpp                # Lógica principal: sensor, relé, WiFiManager e REST
├── supabase/                       # NUVEM E BANCO DE DADOS
│   ├── schema.sql                  # Criação das tabelas de configuração e histórico
│   └── security_auth.sql           # Políticas de segurança e controle de acesso (RLS)
├── frontend/                       # PAINEL WEB (DASHBOARD)
│   ├── index.html                  # Interface gráfica (Tailwind CSS + Lucide Icons)
│   ├── style.css                   # Estilos visuais e compatibilidade mobile touch
│   ├── app.js                      # Conexão WebSockets Realtime e gráficos Chart.js
│   ├── _headers                    # Cabeçalhos de segurança para o Cloudflare Pages
│   └── _redirects                  # Regras de roteamento SPA da Cloudflare
├── wrangler.toml                   # Arquivo opcional para deploy via Cloudflare CLI
└── README.md                       # Documentação técnica do projeto

Perceba como a arquitetura é elegante e separada:

A pasta firmware/ roda dentro do chip ESP32.
A pasta supabase/ configura o banco de dados na nuvem.
A pasta frontend/ é o painel que você abre no navegador do celular ou PC.

Parte 4 — Configurando o Banco de Dados Gratuito no Supabase

O Supabase é uma plataforma em nuvem moderna (baseada em PostgreSQL) que servirá como a “ponte” entre o ESP32 e o painel web. Ele guarda a temperatura atual, o histórico para os gráficos e avisa o navegador instantaneamente quando um valor muda.

O plano gratuito do Supabase é mais do que suficiente para rodar este projeto 24 horas por dia sem nenhum custo.

Passo 1 — Criar uma Conta e um Novo Projeto

Acesse o site supabase.com e crie uma conta gratuita (pode entrar com sua conta do GitHub).
No painel inicial, clique no botão New Project (Novo Projeto).
Preencha as informações:
- Name: Termostato-IoT
- Database Password: crie uma senha forte e anote-a em local seguro.
- Region: escolha a região mais próxima (ex.: South America (São Paulo) para ter o menor tempo de resposta).
Clique em Create new project e aguarde cerca de 1 a 2 minutos enquanto o Supabase provisiona a sua infraestrutura.

Passo 2 — Coletar as Chaves de API (URL e Anon Key)

Com o projeto criado:

No menu lateral esquerdo do Supabase, clique no ícone de engrenagem ⚙️ (Project Settings) e selecione a aba API.
Você verá duas informações fundamentais na tela:
- Project URL: algo no formato https://abcdefghijklmnop.supabase.co
- anon / public key: uma chave longa que começa com eyJhbGci... ou sb_publishable_...
Copie essas duas informações para um bloco de notas; nós vamos usá-las tanto no código do ESP32 quanto no painel web!

Passo 3 — Criar as Tabelas no SQL Editor

No menu lateral esquerdo, clique no ícone SQL Editor (um terminal de código) e depois em New Query.

Copie o conteúdo abaixo (que é exatamente o script oficial supabase/schema.sql), cole na caixa de texto e clique no botão verde Run (Executar):

-- ==============================================================================
-- TERMOSTATO DIGITAL WEB - SUPABASE DATABASE SCHEMA
-- ==============================================================================

-- 1. TABELA DE CONFIGURAÇÃO DO TERMOSTATO (ESTADO ATUAL E PARÂMETROS)
CREATE TABLE IF NOT EXISTS public.thermostat_config (
    id TEXT PRIMARY KEY DEFAULT 'main_thermostat',
    target_temp NUMERIC(4, 1) NOT NULL DEFAULT 25.0,
    hysteresis NUMERIC(3, 1) NOT NULL DEFAULT 1.0,
    mode TEXT NOT NULL DEFAULT 'AUTO_COOL' CHECK (mode IN ('AUTO_COOL', 'AUTO_HEAT', 'MANUAL_ON', 'MANUAL_OFF')),
    relay_state BOOLEAN NOT NULL DEFAULT FALSE,
    current_temp NUMERIC(4, 1),
    current_humidity NUMERIC(4, 1),
    last_seen TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Insere o registro padrão inicial 'main_thermostat'
INSERT INTO public.thermostat_config (id, target_temp, hysteresis, mode, relay_state)
VALUES ('main_thermostat', 25.0, 1.0, 'AUTO_COOL', FALSE)
ON CONFLICT (id) DO NOTHING;

-- 2. TABELA DE HISTÓRICO DE LEITURAS (TELEMETRIA TEMPORAL DHT22)
CREATE TABLE IF NOT EXISTS public.thermostat_logs (
    id BIGSERIAL PRIMARY KEY,
    temperature NUMERIC(4, 1) NOT NULL,
    humidity NUMERIC(4, 1) NOT NULL,
    relay_state BOOLEAN NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

-- Índice para acelerar a busca dos gráficos cronológicos
CREATE INDEX IF NOT EXISTS idx_thermostat_logs_created_at ON public.thermostat_logs(created_at DESC);

-- 3. HABILITAR SEGURANÇA ROW LEVEL SECURITY (RLS)
ALTER TABLE public.thermostat_config ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.thermostat_logs ENABLE ROW LEVEL SECURITY;

-- Políticas de acesso público para o ESP32 e o Painel Web
CREATE POLICY "Permitir SELECT publico em thermostat_config"
    ON public.thermostat_config FOR SELECT
    TO anon, authenticated
    USING (true);

CREATE POLICY "Permitir UPDATE publico em thermostat_config"
    ON public.thermostat_config FOR UPDATE
    TO anon, authenticated
    USING (true)
    WITH CHECK (true);

CREATE POLICY "Permitir SELECT publico em thermostat_logs"
    ON public.thermostat_logs FOR SELECT
    TO anon, authenticated
    USING (true);

CREATE POLICY "Permitir INSERT publico em thermostat_logs"
    ON public.thermostat_logs FOR INSERT
    TO anon, authenticated
    WITH CHECK (true);

-- 4. HABILITAR REALTIME (ATUALIZAÇÃO EM TEMPO REAL VIA WEBSOCKETS)
ALTER PUBLICATION supabase_realtime ADD TABLE public.thermostat_config;

Aparecerá a mensagem verde Success. No rows returned. Isso significa que suas duas tabelas foram criadas com perfeição e a sincronização em tempo real está ativa!

Passo 4 — Criar seu Usuário de Acesso ao Painel

Para impedir que pessoas não autorizadas alterem a temperatura da sua estufa ou freezer pela internet, o painel possui uma tela de login restrita. Vamos criar o seu usuário:

No menu lateral do Supabase, clique no ícone de pessoas Authentication e acesse a aba Users.
Clique no botão Add user e escolha Create user.
Digite seu e-mail (ex.: admin@seudominio.com) e crie uma senha segura (mínimo de 6 caracteres).
Deixe marcada a opção de auto-confirmar e clique em Create user.
Pronto! Esse será o e-mail e senha que você usará para entrar no seu painel web.

Parte 5 — Configurando e Gravando o Firmware no ESP32

Agora vamos preparar o código da placa para que ela saiba se comunicar com o seu banco de dados recém-criado.

Passo 1 — Configurar o Arquivo `config.h`

Abra a pasta firmware/include/config.h em qualquer editor de código (como o VS Code, Notepad++ ou o próprio Bloco de Notas).

Localize as linhas SUPABASE_URL e SUPABASE_KEY e substitua pelos dados do seu projeto que você anotou no Passo 2 da Parte 4:

#pragma once
#include <Arduino.h>

// ==============================================================================
// CONFIGURAÇÃO DO PORTAL WI-FI MANAGER (REDE DE CONFIGURAÇÃO)
// ==============================================================================
#define AP_NAME         "Termostato-ESP32-Setup"  // Nome da rede Wi-Fi temporária da placa
#define AP_PASSWORD     "12345678"                // Senha padrão para conectar

// ==============================================================================
// CONFIGURAÇÃO DA API SUPABASE (SUAS CREDENCIAIS AQUI)
// ==============================================================================
#define SUPABASE_URL    "https://SEU-PROJETO.supabase.co"
#define SUPABASE_KEY    "SUA_CHAVE_ANON_PUBLIC_AQUI"

// ==============================================================================
// CONFIGURAÇÃO DE HARDWARE (PLACA ESP32 RELAY RB2557)
// ==============================================================================
#define RELAY_PIN       16      // GPIO 16 comanda o relé onboard
#define DHT_PIN         4       // GPIO 4 recebe o sinal de dados do DHT22
#define DHT_TYPE        DHT22   // Modelo do sensor

// Lógica de acionamento do relé
#define RELAY_ON_LEVEL  HIGH
#define RELAY_OFF_LEVEL LOW

// Intervalos de tempo em milissegundos
#define SENSOR_READ_INTERVAL_MS 2500      // Leitura da temperatura a cada 2.5s
#define SUPABASE_SYNC_INTERVAL_MS 5000    // Envio para a nuvem a cada 5 segundos
#define SUPABASE_LOG_INTERVAL_MS 60000    // Histórico de gráficos gravado a cada 1 minuto

Salve o arquivo config.h.

Passo 2 — Compilar o Firmware

No terminal, navegue até a pasta firmware:

cd firmware

E execute o comando de compilação do PlatformIO:

pio run

Na primeira vez, o PlatformIO fará o download automático do compilador do ESP32 e de todas as bibliotecas listadas no platformio.ini (Adafruit DHT, ArduinoJson e WiFiManager). Esse processo leva cerca de 1 a 3 minutos. Quando concluir, você verá a mensagem verde:

========================= [SUCCESS] Took XX.XX seconds =========================

Passo 3 — Gravar o Código na Placa pela USB

Com a placa conectada na porta USB do computador, execute:

pio run -t upload

O PlatformIO detectará automaticamente a porta COM e iniciará o envio dos dados (Writing at 0x00010000... [100%]). Ao término, a mensagem Hard resetting via RTS pin... indicará que o firmware foi gravado com sucesso.

💡 Dica de Ouro: Se o terminal ficar preso na linha Connecting........_____..... e der erro de timeout, mantenha o botão BOOT da placa ESP32 pressionado por 2 segundos e solte-o no momento em que o terminal começar a tentar a conexão. Isso força o chip a entrar no modo de recepção de firmware pela serial.

Passo 4 — Abrir o Monitor Serial

Para ver em tempo real o que o ESP32 está pensando e executando, abra o Monitor Serial integrado do PlatformIO:

pio device monitor -b 115200

Se você precisar sair do monitor em qualquer momento, pressione as teclas Ctrl + C.

Parte 6 — Conectando a Placa ao Wi-Fi pelo Portal Captivo

Quando a placa liga pela primeira vez (ou se ela não encontrar a rede salva), ela inicia automaticamente o WiFiManager. Isso significa que você não precisa colocar a senha do seu roteador dentro do código C++!

Pegue o seu celular ou notebook e abra a lista de redes Wi-Fi disponíveis.
Você verá uma nova rede sem fio chamada:
Termostato-ESP32-Setup
Conecte-se a ela. A senha padrão de fábrica é: 12345678.
Uma tela de Portal Captivo será aberta automaticamente no seu navegador móvel (se não abrir, digite no navegador do celular o endereço http://192.168.4.1).
Toque no botão Configure WiFi.
A placa listará todas as redes Wi-Fi de 2.4 GHz do local. Toque no nome da sua rede residencial, digite a sua senha do Wi-Fi e clique em Save.
O ESP32 salvará os dados na memória não-volátil interna (NVS) e reiniciará.

No Monitor Serial do computador, você verá o log de conexão:

[WiFi] Conectado com sucesso!
[WiFi] Endereço IP Local: 192.168.1.105
[Supabase] Conexão SSL estabelecida com sucesso!
[DHT22] Leitura inicial: Temp = 25.4 °C | Umidade = 58.2 %
[Controle] Setpoint = 25.0 °C | Modo = AUTO_COOL | Relé = DESLIGADO

Pronto! A sua placa já está na rede e já está alimentando o banco de dados Supabase a cada 5 segundos!

Parte 7 — O Painel Web e Publicação no Cloudflare Pages

Agora vamos colocar no ar o painel de controle que você poderá acessar de qualquer lugar do mundo através do seu navegador.

7.1 Conhecendo a Interface do Dashboard

A interface web foi desenvolvida com Tailwind CSS, ícones Lucide e biblioteca Chart.js, projetada especificamente para celulares e computadores:

Dashboard do Termostato Digital IoT com exibição em tempo real de temperatura, umidade, relé e curva gráfica

Veja tudo o que a tela oferece:

Card Temperatura Atual: exibe a temperatura em graus Celsius (°C) com precisão decimal e aviso de status comparado ao alvo.
Card Umidade Relativa: exibe a umidade medida pelo sensor DHT22 com atualização instantânea.
Card de Estado do Relé: indica em destaque se a carga está LIGADA (verde brilhante) ou DESLIGADA (cinza), informando se o contato NA está fechado.
Temperatura Alvo (Setpoint): botões circulares táteis de fácil toque (+ e -) para subir ou descer a temperatura desejada em passos de 0,5 °C.
Controle Deslizante de Histerese: ajuste fino da tolerância térmica de $\pm 0,2$ °C até $\pm 5,0$ °C, mostrando os limites exatos de ativação e corte.
Seletores Rápidos de Modo:
- Auto: Resfriar — ideal para freezers, adegas e ventiladores.
- Auto: Aquecer — ideal para chocadeiras, estufas e aquecedores.
- Forçar ON — liga o relé manualmente de forma contínua para testes.
- Forçar OFF — desliga o relé imediatamente por segurança.
Gráfico Histórico em Tempo Real: traça a curva de temperatura minuto a minuto sincronizada com o banco de dados.

7.2 Apontar o Frontend para o seu Supabase

Abra o arquivo frontend/app.js em seu editor de texto. Bem nas primeiras linhas, insira a sua URL e sua chave pública que você pegou no Supabase:

// ==============================================================================
// TERMOSTATO DIGITAL WEB - CONFIGURAÇÃO DO SUPABASE
// ==============================================================================

const SUPABASE_URL = "https://SEU-PROJETO.supabase.co";
const SUPABASE_KEY = "SUA_CHAVE_ANON_PUBLIC_AQUI";

Salve o arquivo frontend/app.js.

7.3 Publicando no Cloudflare Pages (Gratuito e com HTTPS)

O Cloudflare Pages é um serviço de hospedagem de altíssima performance com certificado SSL grátis e proteção global.

Acesse o site dash.cloudflare.com e crie uma conta gratuita.
No menu lateral esquerdo, clique em Workers & Pages.
Clique em Create application e selecione a aba Pages.
Você tem duas opções simples:
- Upload direto (Direct Upload): clique em Upload assets, dê um nome ao projeto (ex.: termostato-meu-esp32) e simplesmente arraste a pasta frontend inteira para a janela do navegador. Clique em Deploy Site.
- Conectar via GitHub: conecte o seu repositório do GitHub e aponte o diretório de compilação para RB2557/Projeto - Termostato Digital Cloudfare Pages e Supabase/frontend.
Em menos de 30 segundos, a Cloudflare gera um link seguro exclusivo (ex.: https://termostato-meu-esp32.pages.dev).

Abra esse link no navegador do seu smartphone ou PC, faça o login com o e-mail e senha que você cadastrou na Parte 4 e pronto: o seu termostato digital já está operando com controle remoto global!

Parte 8 — Como Funciona a Lógica de Histerese na Prática

Um erro muito comum em projetos de iniciantes é tentar fazer o controle térmico com uma condição simples do tipo:
se temperatura > 25 ligue; se não desligue.

Em sistemas térmicos reais, isso causa o chamado efeito chattering (trepidação): quando a temperatura fica oscilando entre 25,01 °C e 24,99 °C, o relé começa a ligar e desligar freneticamente várias vezes por minuto. Isso queima o relé em poucos dias e pode fundir o motor de compressores de geladeira ou ar-condicionado.

Para solucionar isso, nosso projeto utiliza uma Histerese Diferencial Simétrica:

                       MODO AUTO: RESFRIAR (AUTO_COOL)
                       
       Temperatura Subindo                          Temperatura Descendo
              ▲                                              │
              │                                              ▼
   [ 26.0 °C ] ── RELÉ LIGA (Carga ativa)                    │
              │                                              │
   [ 25.0 °C ] ── Setpoint Alvo                              │
              │                                              │
              │                                [ 24.0 °C ] ──┴── RELÉ DESLIGA

Exemplo Prático no Modo Resfriar (`AUTO_COOL`)

Temperatura Alvo Configurada: 25,0 °C
Histerese Configurada: 1,0 °C
Cálculo de Ativação: $25,0 + 1,0 = 26,0$ °C. O relé só fecha os contatos e liga o motor quando o ambiente esquentar até atingir 26,0 °C.
Cálculo de Desativação: $25,0 - 1,0 = 24,0$ °C. O motor permanece trabalhando sem interrupções até o ambiente esfriar completamente e descer a 24,0 °C, momento em que o relé desliga.

Exemplo Prático no Modo Aquecer (`AUTO_HEAT`)

Temperatura Alvo Configurada: 37,5 °C (chocadeira de ovos)
Histerese Configurada: 0,3 °C
Cálculo de Ativação: $37,5 - 0,3 = 37,2$ °C. A resistência de aquecimento liga assim que o ambiente esfriar até 37,2 °C.
Cálculo de Desativação: $37,5 + 0,3 = 37,8$ °C. A resistência desliga ao atingir o teto de 37,8 °C.

Esse intervalo garante vida útil prolongada aos componentes eletromecânicos e estabilidade total ao processo.

Problemas Comuns e Como Resolver

Se algo não funcionar de primeira, consulte a tabela de soluções práticas abaixo:

O que você está vendo?	O que pode estar causando?	Como resolver passo a passo
O terminal diz que `pio` não é um comando reconhecido	O PlatformIO foi instalado mas o terminal antigo continuou aberto sem recarregar o PATH.	Feche todas as janelas do terminal e abra uma nova janela. Teste `python -m pip install platformio` e depois `pio --version`.
No upload aparece `Connecting........_____.....` e dá timeout	O microcontrolador não entrou no modo bootloader UART da ROM.	Mantenha o botão BOOT pressionado na placa ESP32, inicie o comando `pio run -t upload` e solte o botão após 2 segundos.
A temperatura na tela exibe `--` ou `nan`	Falha de contato no pino de dados ou falta do resistor pull-up de 10kΩ.	Verifique se o fio do meio do DHT22 está firme na GPIO 4. Confirme se o resistor de 10kΩ está ligado entre o pino 1 (3.3V) e o pino 2 (DATA).
O ESP32 reinicia sozinho toda vez que o relé tenta ligar	Queda brusca de tensão na fonte quando a bobina do relé atraca.	A fonte USB ou a fonte 12V não está fornecendo corrente estável. Use uma fonte de pelo menos 1A a 2A. Evite alimentar a placa por portas USB antigas de computadores.
O status do aparelho fica sempre “Offline” no painel web	A URL ou a Anon Key do Supabase foram digitadas com erro no `config.h` ou no `app.js`.	Abra o menu API no Supabase, copie novamente a Project URL e a anon key e cole com atenção sem espaços extras no início ou no fim.
O painel não atualiza sozinho quando a temperatura muda	A publicação Realtime não foi ativada na tabela `thermostat_config`.	Abra o SQL Editor no Supabase e rode o comando: `ALTER PUBLICATION supabase_realtime ADD TABLE public.thermostat_config;`.
O relé liga e desliga de forma invertida	Lógica de nível do relé invertida para o seu modelo de módulo.	No arquivo `config.h`, troque `#define RELAY_ON_LEVEL HIGH` por `LOW` e vice-versa, e grave novamente o código.

Conclusão

Parabéns! Você construiu do zero um sistema completo de automação industrial e residencial com tecnologia de ponta:

Hardware Robusto: montou o circuito elétrico integrando ESP32, sensor digital de alta precisão DHT22 e chaveamento isolado por relé.
Ambiente Profissional: aprendeu a compilar e gravar projetos C++ utilizando a linha de comando do PlatformIO.
Rede Inteligente: configurou o Wi-Fi sem precisar expor senhas no código-fonte graças ao Portal Captivo autônomo.
Nuvem em Tempo Real: implementou um banco de dados serverless no Supabase com segurança RLS e replicação via WebSockets.
Dashboard Global: publicou uma aplicação web moderna e responsiva na rede mundial de borda da Cloudflare Pages.
Engenharia de Controle: dominou o conceito de histerese térmica para proteger seus atuadores de potência contra desgastes prematuros.

Explore outras funcionalidades, adicione novos relés para controle duplo (aquecimento e refrigeração simultâneos) e compartilhe seus resultados com a comunidade da RoboBuilders!

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Termostato Digital com ESP32, Supabase e Cloudflare Pages: Projeto Passo a Passo e eu ajudarei a encontrar a solução.

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.