Aprenda ESP32 no seu ritmo

Microcontrolador da Espressif com Wi-Fi e Bluetooth integrados no próprio chip.

Diferente de um Arduino Uno, que precisa de um shield para entrar na rede, o ESP32 já traz o rádio dentro do chip. A linha original usa dois núcleos Xtensa; as mais novas (C3, C6) usam RISC-V. Para automação o que importa são os periféricos: UART para RS-485, SPI e I²C para módulos, ADC para sinais analógicos e GPIOs para entradas e saídas digitais.

Linguagem de baixo nível em que o próprio framework oficial do ESP32 é escrito.

C dá acesso direto à memória e aos registradores do chip, sem camadas intermediárias que consumam tempo de execução. É a linguagem do ESP-IDF, o SDK oficial da Espressif. Quando você precisa de controle fino de temporização ou de memória — o caso típico de firmware industrial — é em C que o código acaba.

Extensão do C com classes e objetos; é a linguagem do Arduino Core.

Todo código C válido é praticamente C++ válido, então as duas convivem no mesmo projeto. O que o C++ acrescenta é organização: agrupar um sensor, seus pinos e seus métodos numa classe em vez de espalhar variáveis globais. O Arduino Core para ESP32 é C++, e é por isso que você escreve `Serial.begin()` em vez de chamar o driver da UART na mão.

Plataforma aberta que simplificou o acesso a microcontroladores — e cuja API roda no ESP32.

Arduino nasceu como placa (a Uno, um AVR de 8 bits, sem rede) mas o que se usa aqui é outra parte dele: o Arduino Core para ESP32, uma camada de compatibilidade que permite programar o chip da Espressif com a API do Arduino — `setup()`, `loop()`, `digitalWrite()`, `Serial`. Ela é construída em cima do próprio ESP-IDF. A vantagem é o acervo enorme de bibliotecas prontas; o preço é a abstração esconder detalhes que, em firmware industrial, uma hora você vai precisar enxergar. Os dois convivem: dá para chamar funções do ESP-IDF de dentro de um projeto Arduino.

Editor de código gratuito da Microsoft, usado como base do ambiente.

Sozinho ele é só um editor — quem o transforma em ambiente de firmware são as extensões. É onde você escreve o código, navega entre arquivos, usa o depurador e abre o terminal. A alternativa histórica é a Arduino IDE, mais simples porém bem mais limitada em projetos com muitos arquivos.

Extensão do VS Code que cuida de compilador, bibliotecas e gravação da placa.

É ela que baixa o toolchain certo, resolve as bibliotecas e grava o firmware. O projeto inteiro é descrito num arquivo `platformio.ini`: qual placa, qual framework (Arduino ou ESP-IDF), quais bibliotecas e em qual versão. Isso torna a compilação reproduzível — outra pessoa clona o repositório e obtém exatamente o mesmo binário.

Over-The-Air: atualizar o firmware pela rede, sem cabo USB e sem ir até o equipamento.

Com uma placa na bancada o USB resolve. Com trinta gateways espalhados pela planta, subir em escada para gravar cada um não é opção. O ESP32 guarda duas partições de aplicação: grava a nova imagem na partição ociosa, verifica a integridade e só então aponta o boot para ela. Se a nova versão não confirmar que subiu bem, o bootloader volta para a anterior — esse rollback é o que separa uma atualização remota de um equipamento inacessível.

Protocolo de mensagens leve, no modelo publica/assina, com um broker no meio.

Os dispositivos não conversam entre si: publicam mensagens em tópicos (como `fabrica/linha1/temperatura`) num servidor central, o broker, e quem tiver interesse assina aquele tópico. Isso desacopla quem produz o dado de quem consome. Foi desenhado para links ruins, o que importa no chão de fábrica: tem níveis de entrega (QoS) e o Last Will, uma mensagem que o broker publica sozinho quando um dispositivo cai sem avisar.

O servidor no meio do MQTT: tudo passa por ele, e nada passa sem ele.

O ESP32 nunca fala com o supervisório diretamente — publica no broker, e o broker entrega a quem assinou o tópico. Isso é o que permite trocar o consumidor do dado sem tocar no firmware. Ele também guarda estado: a mensagem retida (o último valor de um tópico, entregue na hora a quem chega depois) e a sessão persistente (as mensagens que ficam na fila enquanto um cliente está offline). É onde vivem a autenticação e as permissões por tópico, de quem pode publicar e quem só pode ler.

Interface sobre HTTP em que cada endereço é um recurso e o cliente pergunta quando quer.

É o modelo pergunta-e-resposta: alguém chama `GET /api/temperatura` e recebe um JSON de volta. A diferença para o MQTT é quem toma a iniciativa — no REST o cliente puxa o dado quando precisa, no MQTT o broker empurra assim que ele muda. Na prática os dois convivem: MQTT para telemetria contínua, REST para consulta sob demanda, configuração e integração com sistemas que já falam HTTP. O ESP32 faz os dois papéis: serve endpoints próprios (é assim que funciona o portal de configuração embarcado) e consome APIs externas.

Padrão elétrico para levar sinal por centenas de metros em ambiente com ruído.

Não é protocolo: é só o meio físico, e não diz nada sobre o formato da mensagem. O truque é a transmissão diferencial — o dado vai como a diferença de tensão entre dois fios de um par trançado, então o ruído que entra nos dois é cancelado na chegada. Permite vários dispositivos no mesmo par, em topologia de barramento, com resistores de 120 Ω nas duas pontas para evitar reflexão. O ESP32 não fala RS-485 direto: precisa de um transceiver, tipo o MAX485, entre a UART e a linha.

Protocolo industrial de 1979 que praticamente todo equipamento de campo entende.

Funciona por pergunta e resposta: um mestre pede, o escravo responde — nenhum escravo fala sozinho. Os dados moram em registradores numerados, lidos e escritos por códigos de função. Vem em duas formas: RTU, binário sobre serial (tipicamente RS-485), e TCP, o mesmo modelo sobre Ethernet. A força dele é a onipresença; a fraqueza é não ter semântica alguma — o registrador 40001 é só um número de 16 bits, e o que ele significa está no manual do fabricante, não no protocolo.

Padrão industrial moderno que transporta o dado junto com o significado dele.

Onde o Modbus entrega um número solto, o OPC UA entrega um objeto nomeado, com tipo, unidade e descrição — o servidor publica um modelo de informação que o cliente navega. Traz segurança na própria especificação: certificados, autenticação e criptografia, em vez de depender da rede ser confiável. O preço é o peso: é bem mais pesado que Modbus, e por isso costuma aparecer da camada de supervisão para cima, não no sensor mais simples.

A camada de supervisão: reúne o dado do campo, mostra, alarma e guarda histórico.

Supervisory Control and Data Acquisition. É o sistema que conversa com CLPs e gateways, desenha as telas sinóticas, dispara alarmes quando um valor sai da faixa e mantém o histórico para análise depois. Não confundir com IHM: a IHM é local, presa a uma máquina; o SCADA enxerga a planta inteira e normalmente roda em servidor. Para o ESP32, o SCADA costuma ser o destino final do dado — direto ou via broker MQTT.

Industrial Internet of Things: a aplicação de IoT ao chão de fábrica.

A diferença para o IoT de consumo não é a tecnologia, é a exigência. Aqui o dado vem de CLPs, medidores de energia e sensores de processo, muitas vezes por protocolos antigos como Modbus, e precisa chegar sem falhas a supervisórios e bancos de dados. É o que se chama de integração OT/IT: ligar a rede da operação à rede corporativa sem comprometer nenhuma das duas.