Tag: Esp32

  • ESP32: O Arduino Que Aprendeu a Falar

    O Arduino Uno é um monge silencioso: faz o que você manda, rápido e sem distrações. O ESP32 é o amigo que acabou de descobrir a internet e quer te mostrar tudo ao mesmo tempo. Dual-core, WiFi, Bluetooth, 240 MHz, 520 KB de SRAM — tudo isso por menos de R$ 30 no Mercado Livre. Quando você conecta um ESP32 pela primeira vez, a pergunta deixa de ser “o que eu posso fazer com um microcontrolador” e passa a ser “o que eu não posso”.

    A História da Espressif

    A Espressif Systems foi fundada em 2008 em Xangai por Teo Swee Ann, um engenheiro de Cingapura que estudou na Universidade de Tsinghua. A empresa inicialmente focava em chips de rádio para aplicações de WiFi de baixo consumo. Em 2014, lançaram o ESP8266 — um módulo WiFi barato, originalmente pensado como ponte serial-para-WiFi para outros microcontroladores. Mas a comunidade hacker percebeu algo que a Espressif não tinha planejado: o ESP8266 tinha um processador bom o suficiente para rodar código próprio. Em meses, surgiram firmwares alternativos (NodeMCU, MicroPython) e a placa virou um microcontrolador independente com WiFi — por US$ 3.

    O ESP32 chegou em 2016 como a resposta madura a essa descoberta acidental: processador dual-core Tensilica Xtensa LX6, WiFi 802.11 b/g/n, Bluetooth 4.2 + BLE, 34 GPIOs, touch sensors, DAC, CAN bus, Ethernet MAC. A Espressif entendeu o recado: o mercado não queria um módulo WiFi auxiliar — queria um cérebro conectado.

    ESP32 vs. Arduino Uno vs. Raspberry Pi Pico

    Vamos ser diretos — números na mesa:

    Especificação Arduino Uno R3 ESP32 (WROOM) Raspberry Pi Pico (RP2040)
    Processador ATmega328P 8-bit Xtensa LX6 32-bit dual-core RP2040 ARM Cortex-M0+ dual-core
    Clock 16 MHz 240 MHz 133 MHz
    RAM 2 KB SRAM 520 KB SRAM 264 KB SRAM
    Flash 32 KB 4 MB (externo) 2 MB (externo)
    WiFi Não Sim Não (precisa do Pi Pico W)
    Bluetooth Não Sim Não
    GPIOs 14 (6 PWM) 34 (16 PWM) 26 (16 PWM)
    Preço (BR) ~R$ 70-120 ~R$ 25-50 ~R$ 20-40

    O ESP32 tem um hardware muito superior ao Arduino Uno pelo mesmo preço (ou menos). A diferença é que o ecossistema do Arduino é mais maduro para iniciantes: bibliotecas mais testadas, mais tutoriais, menos armadilhas. O ESP32 exige que você preste atenção em detalhes como nível lógico de 3.3V (conectar 5V nos GPIOs queima a placa), partição de memória e gerenciamento de energia. Mas a recompensa é uma placa que literalmente conversa com a internet.

    Primeiro Projeto Além do Blink: Conectar ao WiFi

    Se o ritual do Arduino é piscar um LED, o ritual do ESP32 é conectar ao WiFi. Vamos fazer isso em três passos.

    1. Preparar o Ambiente

    Na Arduino IDE, instale o suporte a ESP32: vá em Arquivo > Preferências > URLs adicionais de placas e cole:

    https://espressif.github.io/arduino-esp32/package_esp32_index.json

    Depois em Ferramentas > Placa > Gerenciador de Placas, busque por “ESP32” e instale o pacote “esp32 by Espressif Systems”. Selecione a placa “ESP32 Dev Module” e a porta COM correta.

    2. O Código

    #include <WiFi.h>
    
    const char* ssid = "NOME_DA_SUA_REDE";
    const char* password = "SENHA_DA_REDE";
    
    void setup() {
      Serial.begin(115200);
      WiFi.begin(ssid, password);
      
      Serial.print("Conectando");
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
      
      Serial.println();
      Serial.print("Conectado! IP: ");
      Serial.println(WiFi.localIP());
    }
    
    void loop() {
      // Seu código principal aqui
    }
    

    3. O Que Fazer Depois

    Com WiFi, o ESP32 pode: enviar dados de sensores para a nuvem (MQTT, HTTP), receber comandos remotos, servir uma página web no seu navegador, acionar relés pelo celular, postar temperatura no ThingSpeak, criar um dashboard no Home Assistant. O limite não é mais o hardware — é sua imaginação.

    Dica Especial: ESP32-CAM

    Se você quer um projeto que impressiona visualmente, compre uma ESP32-CAM (R$ 30-50 no Mercado Livre). É um ESP32 com slot para câmera OV2640 de 2MP, slot para cartão microSD e LED de flash. Com ela você faz: câmera de segurança WiFi, timelapse, reconhecimento facial básico (com a biblioteca ESP-WHO da Espressif), fotografia remota. Só precisa de um programador FTDI externo para o primeiro upload — depois, OTA (Over-The-Air) resolve.

    No meu setup, tenho uma ESP32-CAM apontada para a impressora 3D transmitindo timelapse para um servidor local. Custo total: R$ 45 e uma tarde de sábado. Isso era projeto de empresa em 2015.

    O Futuro: ESP32-S3 e Além

    A Espressif não parou no ESP32 original. A família cresceu: ESP32-S2 (USB nativo, sem Bluetooth), ESP32-S3 (AI acceleration, USB OTG, mais GPIOs), ESP32-C3 (RISC-V, WiFi 6, Bluetooth 5), ESP32-C6 (WiFi 6 + Zigbee + Thread — Matter ready). Cada novo chip resolve uma lacuna diferente. Para começar, o ESP32 WROOM clássico ainda é o rei: barato, maduro, suportado por tudo.

    Fontes e Referências

  • Automação Residencial com ESPHome: Sua Casa Inteligente Sem Nuvem Alheia

    Quando eu digo “casa inteligente”, qual imagem aparece na sua cabeça? Se for um assistente de voz que manda seus hábitos pra um datacenter em Ohio, temos um problema. Automação de verdade não precisa de internet — precisa de sensores, atuadores e um cérebro que mora dentro da sua casa. O combo ESP32 + ESPHome + Home Assistant faz exatamente isso: você controla luzes, temperatura, portões e cortinas com zero dependência de servidor externo. Se a internet cair, sua casa continua inteligente.

    A Filosofia da Casa Offline

    Em 2026, o mercado de dispositivos smart home é dominado por marcas como Tuya, Sonoff e Philips Hue — todas funcionando, em maior ou menor grau, dependentes de nuvens proprietárias. O problema não é ideológico — é prático: servidores caem, empresas são compradas (lembra do Revolv da Nest?), APIs são descontinuadas, e de repente sua lâmpada inteligente de R$ 200 virou peso de papel.

    O ESPHome é um projeto open-source que resolve isso de raiz. Criado por Otto Winter em 2018 e integrado ao ecossistema Nabu Casa (os mesmos do Home Assistant), ele compila firmware personalizado para ESP8266 e ESP32 a partir de um simples arquivo YAML. Você escreve o que quer que a placa faça — ler um sensor, acionar um relé, controlar um LED PWM — e o ESPHome gera o firmware C++ correspondente e faz upload via USB ou OTA. Sem programar em C. Sem IDE. Sem bibliotecas conflitantes.

    Primeiro Projeto: Termostato Inteligente

    Vamos construir um sensor de temperatura e umidade com DHT22 que reporta ao Home Assistant e aciona um ventilador via relé quando a temperatura passa de 28°C. Objetivo prático: seu quarto não virar uma sauna no verão.

    Materiais

    • ESP32 DevKit V1 (~R$ 30-50 — FilipeFlop ou Robocore)
    • DHT22 (AM2302) — sensor de temperatura e umidade digital, preciso, ~R$ 15-25
    • Módulo relé 5V de 1 canal — para acionar o ventilador, ~R$ 12-20
    • Fonte 5V com micro-USB ou regulador de tensão para alimentar o ESP32
    • Resistor 10kΩ — pull-up para o pino de dados do DHT22 (alguns módulos já vêm com ele)

    Montagem

    São três conexões básicas:

    1. DHT22: VCC (pino 1) → 3.3V do ESP32. GND (pino 4) → GND. DATA (pino 2) → GPIO 23 do ESP32. Com resistor 10kΩ entre DATA e 3.3V (pull-up).
    2. Relé: VCC → 5V do ESP32 (ou VIN se alimentado por USB). GND → GND. IN (sinal) → GPIO 26 do ESP32.
    3. Carga (ventilador): Fio fase do ventilador passa pelo borne NA (Normalmente Aberto) do relé. Quando o relé fecha, o circuito fecha e o ventilador liga.

    O Arquivo YAML do ESPHome

    Crie um arquivo termostato.yaml no diretório de configuração do ESPHome:

    esphome:
      name: termostato-quarto
      friendly_name: Termostato Quarto
    
    esp32:
      board: esp32dev
      framework:
        type: arduino
    
    # Configura WiFi
    wifi:
      ssid: !secret wifi_ssid
      password: !secret wifi_password
    
    # API para Home Assistant
    api:
      encryption:
        key: !secret api_key
    
    ota:
      - platform: esphome
        password: !secret ota_password
    
    # Sensor DHT22 no GPIO 23
    sensor:
      - platform: dht
        pin: GPIO23
        model: DHT22
        temperature:
          name: "Temperatura Quarto"
          id: temp_quarto
        humidity:
          name: "Umidade Quarto"
        update_interval: 60s
    
    # Relé no GPIO 26
    switch:
      - platform: gpio
        pin: GPIO26
        name: "Ventilador Quarto"
        id: ventilador
        restore_mode: ALWAYS_OFF
    
    # Automação local: liga ventilador se temp > 28°C
    climate:
      - platform: thermostat
        name: "Termostato Quarto"
        sensor: temp_quarto
        default_target_temperature_low: 24 °C
        default_target_temperature_high: 28 °C
        min_cooling_run_time: 120s
        min_idle_time: 120s
        cool_action:
          - switch.turn_on: ventilador
        idle_action:
          - switch.turn_off: ventilador
    

    O ESPHome agora oferece um thermostat climate controller nativo — você define um sensor de temperatura e um switch, e ele gerencia a histerese sozinho. Sem programar lógica de controle. O YAML é declarativo: você diz o que quer, o compilador resolve o como.

    Primeiro Upload

    1. Instale o ESPHome Dashboard (basta um pip install esphome no terminal).
    2. Conecte o ESP32 via USB. Rode esphome run termostato.yaml.
    3. Na primeira vez, o upload é feito por USB. Depois, as atualizações podem ser over-the-air (OTA) — sem cabo.
    4. O Home Assistant detecta o dispositivo automaticamente via mDNS e pergunta se você quer adicioná-lo.

    Por Que Isso É Poderoso

    O que acabamos de fazer é uma automação que roda localmente. O ESP32 toma decisões sozinho com base na temperatura que ele mesmo mede. O relé fecha sem consultar servidor nenhum. Se o Home Assistant estiver offline, o ESPHome continua funcionando — o climate controller é embarcado no firmware.

    Compare isso com uma lâmpada Tuya que precisa enviar o comando “liga” para um servidor em Shenzhen, que devolve a confirmação, que chega na lâmpada, que finalmente acende — com 3 segundos de delay em dia bom. Casa inteligente de verdade é casa que responde em milissegundos.

    Expandindo: Sensores e Atuadores Suportados

    O ESPHome tem suporte nativo para centenas de componentes. Alguns que uso no meu setup:

    • LD2410 (sensor de presença por radar mmWave): detecta se tem gente no ambiente mesmo parado — acende e apaga luz automaticamente.
    • BME280: temperatura, umidade e pressão atmosférica em um sensor só. Mais preciso que o DHT22 para temperatura.
    • Display OLED SSD1306: mostra temperatura e status na própria placa.
    • Servo motor: controla cortinas, persianas, ventiladores direcionais.
    • Neopixel (WS2812B): fita LED endereçável para iluminação ambiente.

    O ESPHome tem integração nativa com todos esses. É só adicionar o bloco YAML correspondente.

    A Realidade do Mercado Brasileiro

    No Brasil, automação residencial comercial (Lutron, Crestron) é inviável para 99% das pessoas. Um interruptor inteligente Zigbee da Philips hue custa R$ 300. Um ESP32 de R$ 30 + relé de R$ 15 + case impresso em 3D de R$ 5 faz a mesma coisa, com mais flexibilidade e sem depender de hub proprietário. O trade-off é que você precisa montar — e é exatamente isso que torna o maker diferente do consumidor.

    Comece pelo termostato. Depois adicione um sensor de presença no corredor. Depois um relé no portão. Depois um sensor de gás na cozinha. Aos poucos, sua casa vai ficando mais inteligente, um ESP32 de cada vez. E quando a internet cair, você nem vai notar.

    Fontes e Referências