Conhecendo a
família ESP32

A LASER, Liga Acadêmica de Sistemas Embarcados do Centro de Informática da UFPE tem como propósito fortalecer a área de sistemas embarcados na universidade, promovendo estudo, pesquisa e aplicação de tecnologias que envolvem tanto hardware quanto software. Suas frentes vão de automação e Internet das Coisas a IA na borda, robótica, sistemas críticos, tecnologias veiculares e engenharia biomédica.

Esta apostila acompanha a formação em ESP32 da liga. A escolha da plataforma não é acidental: o ESP32 atravessa quase todas as frentes da LASER. Ele é o nó de IoT, é a placa de automação, roda inferência na borda, e é barato o bastante para que cada pessoa tenha o seu.

O que você vai levar deste módulo

• Entender o que existe dentro de um ESP32 e por que ele é diferente de um Arduino.
• Saber navegar as doze séries da família sem se perder na nomenclatura.
• Ter um método objetivo para escolher a série de um projeto novo.
• Reconhecer as limitações reais da plataforma antes de esbarrar nelas.
• Sair com um sensor real lendo temperatura e umidade na sua bancada.

Pré-requisitos

Espera-se que você já tenha ligado um LED em algum microcontrolador e saiba o que é uma porta digital. Programação em C ou C++ em nível básico ajuda, mas o código da prática é curto e comentado. Não é preciso saber nada de Wi-Fi, RTOS, RISC-V ou criptografia. Tudo isso aparece explicado no caminho.

Material para a prática

Uma placa ESP32-S3-DevKitC-1, um sensor DHT11, um resistor de 10 kΩ, jumpers, protoboard e um cabo USB de dados. A lista completa e o esquema de ligação estão no capítulo 9.

Como esta apostila está organizada

Os capítulos 1 a 3 constroem o entendimento do hardware. Os capítulos 4 a 6 apresentam a família e comparam com alternativas. Os capítulos 7 e 8 são de decisão: como escolher série e ferramenta. O capítulo 9 é a prática, e o 10 fecha com glossário e caminhos de estudo.

O ESP32 é uma linha de microcontroladores da Espressif Systems, empresa fundada em 2008 e sediada em Xangai. A história que interessa começa em 2014, com o ESP8266: um chip barato de Wi-Fi vendido como "módulo serial para internet", que a comunidade descobriu ser, na verdade, um microcontrolador completo por poucos dólares.

Em 2016 veio o ESP32 original, já projetado como plataforma: dois núcleos, Wi-Fi, Bluetooth e um conjunto grande de periféricos. A partir de 2020 a linha se ramificou, e hoje são doze séries, cada uma otimizada para um recorte diferente de custo, consumo, conectividade e desempenho.

Linha do tempo

O que explica a adoção

Antes do ESP8266, colocar um projeto na internet significava comprar um microcontrolador e um módulo de rede, ligá-los por serial ou SPI, e gastar boa parte da memória disponível com a pilha de comunicação. O ESP32 traz o rádio dentro do mesmo encapsulamento do processador, com as pilhas de Wi-Fi e Bluetooth prontas, testadas em campo por centenas de milhões de dispositivos.

Some a isso o preço, já que um módulo custa menos que muitos microcontroladores sem rádio, e uma documentação pública completa, com datasheets, manuais de referência e código-fonte abertos. Essa combinação é rara no mercado de semicondutores.

SoC, módulo, placa e série: quatro coisas diferentes

Muita confusão nasce de usar "ESP32" para quatro coisas distintas. Vale separar desde já, porque isso muda o que você compra, quanto custa e como projeta:

O que a Espressif entrega junto com o silício

Boa parte do valor do ESP32 não está no chip, e sim no software que vem junto. O ESP-IDF (Espressif IoT Development Framework) é o ambiente oficial: baseado em FreeRTOS, traz as pilhas de Wi-Fi, Bluetooth, TCP/IP, TLS, atualização remota de firmware (OTA), sistemas de arquivos, provisionamento e ferramentas de depuração. É software que levaria anos para uma equipe escrever do zero.

Existe também o core Arduino para ESP32, que traduz esse ambiente para as funções que você já conhece. É a porta de entrada, e é o que usaremos na prática, mas por baixo continua sendo o ESP-IDF rodando. Entender isso ajuda quando algo não funciona: muitas respostas estão na documentação do IDF, não na do Arduino.

Processador: Xtensa ou RISC-V

As séries mais antigas (ESP32, S2, S3) usam núcleos Xtensa, arquitetura licenciada da Cadence. As séries novas (C2, C3, C5, C6, C61, H2, H4, P4, S31) migraram para RISC-V, um conjunto de instruções aberto e livre de royalties.

Para quem programa em C, a diferença é quase invisível, porque o compilador cuida disso. Ela aparece quando você precisa de assembly, de ferramentas de análise de baixo nível, ou quando uma biblioteca pré-compilada existe só para uma das arquiteturas. A tendência é clara: todo lançamento recente é RISC-V.

Um ou dois núcleos, e o que fazer com eles

Séries como ESP32, S3, P4, H4 e S31 têm dois núcleos. No ESP-IDF eles recebem nomes: PRO_CPU (núcleo 0) e APP_CPU (núcleo 1). Por convenção, as tarefas do Wi-Fi e do Bluetooth rodam no núcleo 0, deixando o 1 mais livre para o seu código. É possível fixar uma tarefa em um núcleo específico, recurso valioso quando você precisa de um laço com temporização mais previsível.

O coprocessador de baixo consumo

Algumas séries trazem um segundo processador de baixíssimo consumo, o ULP ou LP core. Ele continua acordado enquanto o processador principal dorme, lendo um sensor de tempos em tempos e só acordando o resto do chip quando algo interessa. É o que permite um projeto a bateria durar meses em vez de dias.

Memória: quatro tipos, quatro papéis

O rádio não é de graça: transmitir custa corrente, com picos que passam de 300 mA, ocupa memória e consome tempo de processamento. Voltaremos a isso no capítulo 7.

Periféricos e a matriz de roteamento

GPIO, UART, SPI, I²C, I²S, PWM, ADC, sensor de temperatura interno, USB, controlador CAN (que a Espressif chama de TWAI), contador de pulsos, transceptor de infravermelho. O conjunto varia por série.

Uma característica facilita muito a vida: na maioria das séries existe uma matriz de roteamento (GPIO matrix) que permite mapear quase qualquer função para quase qualquer pino, por software. Em um microcontrolador tradicional, a UART2 só existe nos pinos que o fabricante escolheu; aqui, você decide na hora de programar. Na prática do projeto de placa isso é ouro: você desenha o traçado da forma mais limpa e depois adapta o firmware.

Pinos com restrição, e o estrago que eles causam

Aqui está a diferença mais concreta entre ler o datasheet e não ler. Num Arduino UNO, os vinte pinos são praticamente equivalentes. Num ESP32, uma parte deles já tem dono, e usar o pino errado não produz um erro de compilação: produz uma placa que não liga, um firmware que trava, ou pior, um protótipo que funciona na bancada e falha em campo.

São cinco grupos, e cada um quebra o projeto de um jeito diferente.

1. Ligados à memória flash ou PSRAM

Estes pinos conversam com a memória de onde o firmware está sendo lido, o tempo todo, enquanto o chip funciona. Escrever neles interrompe essa conversa no meio.

Como falha: o chip reinicia em laço, ou trava no boot com uma mensagem de erro de leitura da flash. Não é intermitente e não tem contorno em software.

Como evitar: no ESP32-S3 são os GPIO 26 a 32; no ESP32 clássico, os GPIO 6 a 11 (mais o 16 e o 17 em módulos WROVER, que têm PSRAM). Boa notícia: em muitos módulos esses pinos nem chegam à barra de pinos, justamente para você não ter como errar.

2. Strapping (seleção do modo de boot)

O chip lê o nível destes pinos no instante do reset para decidir como inicializar. Depois do boot eles voltam a ser GPIO normais, e é aí que mora a armadilha: o pino funciona perfeitamente enquanto a placa está ligada, mas o que você pendurou nele atrapalha o próximo reset.

Como falha: a placa para de iniciar quando o circuito externo puxa o pino para o nível errado. Um exemplo comum: você liga um LED com resistor no GPIO0 do ESP32. O LED funciona. Na próxima energização, o resistor mantém o pino em nível baixo, o chip entende que deve entrar em modo de gravação e fica esperando um firmware que nunca chega. A placa parece morta.

Como evitar: reserve os pinos de strapping para saídas que ficam em alta impedância no boot, ou use-os para entradas com o resistor de pull no sentido que o chip espera. Se puder, simplesmente não use.

3. Somente entrada

Alguns pinos são fisicamente incapazes de acionar uma saída, e não têm resistores de pull-up nem pull-down internos.

Como falha: silenciosamente. O pinMode(pino, OUTPUT) não reclama, o digitalWrite não reclama, e o pino simplesmente não muda de nível. Você passa a tarde procurando o problema no código.

Como evitar: no ESP32 clássico são os GPIO 34, 35, 36, 37, 38 e 39. Use-os para leitura, e lembre de colocar o resistor de pull no circuito, já que não existe um interno para ativar. As séries RISC-V mais novas não têm pinos assim.

4. Gravação e depuração

São a UART0 (por onde o firmware é gravado e as mensagens de Serial saem) e as quatro linhas de JTAG.

Como falha: você não perde o projeto, perde a capacidade de trabalhar nele. Se um sensor ocupa os pinos da UART0, cada gravação exige desconectar o sensor. Se algo escreve nesses pinos durante a execução, o monitor serial enche de lixo.

Como evitar: deixe a UART0 livre até o projeto estar fechado. Se precisar de mais uma serial, use a UART1 ou a UART2, que a matriz de roteamento leva para quase qualquer pino.

5. USB nativo

Nas séries com USB no próprio chip, dois pinos saem de fábrica ligados ao periférico USB Serial/JTAG.

Como falha: ao usá-los como GPIO comum, a porta USB de gravação some do computador. Recuperar exige o modo de gravação manual pelos botões BOOT e RESET.

Como evitar: no ESP32-S3 são o GPIO19 e o GPIO20. Trate-os como indisponíveis, a não ser que você tenha certeza de que não vai precisar do USB nativo.

A sequência de partida

FreeRTOS: seu código não está sozinho

Diferente de um Arduino UNO, onde o seu loop() é literalmente a única coisa executando, no ESP32 há um sistema operacional de tempo real gerenciando várias tarefas ao mesmo tempo: a sua, as do Wi-Fi, as do Bluetooth, o temporizador de sistema, o coletor de estatísticas.

O escalonador distribui o processador entre elas por prioridade. Isso traz dois efeitos práticos que surpreendem quem vem do Arduino:

Primeiro: um delay() no ESP32 não trava o chip: ele cede o processador para outras tarefas. É por isso que o Wi-Fi continua funcionando enquanto o seu código "espera".

Segundo: um laço que nunca cede o processador causa problema. Se você escrever um while(true) sem delay() nem espera, o watchdog vai reiniciar o chip, reclamando que a tarefa não alimentou o cão de guarda. Não é bug: é o sistema protegendo as tarefas do rádio.

Partições: a flash não é um bloco só

A memória flash é dividida segundo uma tabela de partições. Um layout típico tem: o bootloader, a tabela em si, uma área nvs para guardar configurações (como a senha do Wi-Fi), uma ou duas partições de aplicação e, às vezes, um sistema de arquivos.

Duas partições de aplicação existem para permitir OTA: o firmware novo é gravado na partição inativa, e só depois de validado o chip passa a iniciar por ela. Se a imagem nova falhar, ele volta sozinho para a anterior. É por isso que um projeto com atualização remota precisa de mais que o dobro do espaço do firmware.

A nomenclatura ajuda mais do que parece. A letra indica a vocação da série: S de sensing, desempenho e USB; C de custo reduzido em RISC-V; H de malha 802.15.4 sem Wi-Fi; P de processamento bruto sem rádio.

Tabelas comparativas

Processamento e memória

Rádios

Ferramentas e encapsulamento

Segurança costuma ser tratada como assunto de software, mas boa parte dela depende de blocos de hardware. Executar criptografia em hardware é dezenas de vezes mais rápido e mais econômico que na CPU. E alguns recursos, como esconder uma chave privada do próprio firmware, são impossíveis sem apoio do silício.

Este é também o assunto em que as séries mais divergem, o que faz dele um bom critério de escolha.

Os blocos e o que cada um resolve

O que cada série tem

Três leituras que essa tabela permite

Nem toda série tem acelerador AES. O C2 e o C61 não têm. Eles conseguem fazer TLS, mas a cifra do tráfego roda na CPU, o que pesa se o dispositivo transmitir muito dado.

ECC é um divisor claro. As séries mais antigas (ESP32, S2, S3 e C3) não têm curvas elípticas em hardware. Como o mundo caminha para ECC (chaves menores, menos memória), essa é uma diferença que tende a pesar mais com o tempo.

Key Manager é raro. Só S31, C5 e P4. Se o seu produto precisa que a chave privada seja inacessível mesmo para quem tem o firmware em mãos, a lista de candidatos é bem curta.

Comparar plataformas exige cuidado: "Arduino" é uma marca de placas e um ambiente de programação, e "STM32" é uma família enorme da STMicroelectronics que vai de chips de centavos a processadores de 480 MHz. Para a comparação fazer sentido, usaremos representantes concretos.

Onde cada um ganha

Arduino UNO

Ganha em simplicidade e previsibilidade. Sem sistema operacional, sem pilha de rede: o que você escreve é exatamente o que executa, na ordem que escreveu. Trabalha em 5 V, o que dispensa conversão de nível com muitos sensores e módulos antigos. É insuperável como primeiro contato e para ensinar eletrônica. Perde feio em memória, porque 2 KB de SRAM acabam rápido, e não tem qualquer conectividade.

ESP8266

Ganha em preço puro. Ainda é o jeito mais barato de colocar algo simples no Wi-Fi, e tem uma base gigante de tutoriais. Perde em quase todo o resto: poucos GPIOs utilizáveis, um único canal de ADC, sem Bluetooth, e uma arquitetura que a Espressif já não desenvolve. Para projeto novo, o C3 costuma custar quase o mesmo e é melhor em tudo.

ESP32

Ganha em conectividade e relação recurso/preço. Você recebe centenas de kilobytes de RAM, dois núcleos, Wi-Fi, Bluetooth e criptografia por hardware pelo preço de um microcontrolador simples. Para qualquer coisa que precise falar com a rede, é difícil justificar outra escolha. Perde em determinismo de tempo real rígido e na qualidade do conversor analógico.

STM32

Ganha em controle fino e diversidade. A família cobre desde encapsulamentos de 8 pinos até chips com centenas, com variantes especializadas em consumo ultrabaixo (série L), desempenho (H7) ou segurança. Os periféricos de temporização são muito superiores para controle de motor e conversão de potência, e o ecossistema é padrão industrial, com ferramentas de certificação e suporte de longo prazo. Perde na curva de aprendizado, já que a HAL da ST é bem mais verbosa, e não tem rádio integrado, salvo nas séries WB e WL.

Onde o ESP32 é muito bom

Conectividade sem dor. Subir um cliente MQTT com TLS, um servidor HTTP ou uma conexão BLE são tarefas de dezenas de linhas, com pilhas maduras.

Recursos por real gasto. Nenhuma outra plataforma entrega tanta memória, clock e rádio nessa faixa de preço.

Segurança de verdade. Boot seguro, criptografia de flash e aceleradores criptográficos estão presentes até nas séries baratas, recursos que em outras famílias aparecem só nas linhas premium.

Flexibilidade de pinos. A matriz de roteamento simplifica muito o traçado da placa: você adapta o firmware ao layout, não o contrário.

Atualização remota. OTA com partição dupla e reversão automática vem pronto no framework.

Documentação aberta. Datasheets, manuais de referência, erratas e o código-fonte do framework são públicos e versionados.

Onde ele decepciona

O conversor analógico é fraco

É a queixa mais comum e mais justa. O ADC do ESP32 tem não-linearidade perceptível, ruído e variação entre unidades; precisa de calibração para medidas sérias. Pior: em várias séries, o bloco ADC2 fica indisponível enquanto o Wi-Fi está ligado, porque ambos compartilham recursos internos. Se o seu projeto depende de medida analógica precisa, use um ADC externo por I²C ou SPI.

O rádio consome muito

Picos de transmissão passam de 300 mA. Um regulador subdimensionado ou uma bateria com resistência interna alta provoca reinicializações aparentemente aleatórias, que parecem bug de software e não são.

Tempo real é aproximado

O firmware roda sobre FreeRTOS, e o rádio tem tarefas de alta prioridade que precisam ser atendidas. Isso introduz variação de alguns microssegundos a milissegundos no seu laço. Existem soluções, como fixar tarefa em um núcleo, usar o periférico RMT ou delegar a hardware dedicado, mas todas exigem planejamento.

Só 3,3 V

Os pinos não toleram 5 V. Sensor ou display antigo em 5 V exige conversor de nível; ligar direto degrada ou destrói a entrada.

Documentação viva demais

A família cresce rápido, e com ela erratas, diferenças entre revisões de silício e funcionalidades que mudam de comportamento entre versões do IDF. Ler a errata do seu chip antes de fechar o projeto é hábito recomendado.

Consumo em repouso não é mágico

Os 7 µA de deep sleep que aparecem no datasheet valem para o chip nu, em condições ideais. Numa placa de desenvolvimento, o regulador, o LED de energia e o conversor USB-serial costumam consumir muito mais que o próprio ESP32. Medir consumo em DevKit leva a conclusões erradas.

A escolha fica muito mais simples quando feita na ordem certa. Comece pelo que é impossível contornar depois, que é o rádio, e só no fim olhe para o que é ajustável.

Pergunta 1: Como ele se comunica?

Esta pergunta sozinha elimina a maior parte da família, porque rádio não se acrescenta depois.

Pergunta 2: De onde vem a energia?

Se o projeto vive de bateria ou painel solar, o consumo em repouso passa a mandar em tudo. Séries com processador de baixo consumo (C5, C6, P4, S31) mantêm uma tarefa simples rodando com o resto do chip dormindo. E se você não precisa de Wi-Fi, o H2 e o H4 economizam justamente por não carregarem o rádio mais faminto.

Pergunta 3: O que vai ligado nele?

Conte os pinos de que precisa e verifique as interfaces especiais. Display gráfico grande ou câmera pedem S3 ou P4 (que tem MIPI). Muitos atuadores pedem uma série com bastante GPIO, lembrando de descontar os pinos com restrição. USB nativo, para o dispositivo se apresentar como teclado ou pendrive, existe do S2 em diante e nas séries C recentes.

Pergunta 4: Que exigência de segurança existe?

Para um protótipo, qualquer série serve. Para produto, o requisito define o chip: atestado de dispositivo Matter pede ECDSA em hardware; chave privada que o firmware nunca pode ler pede Key Manager. Consulte a tabela do capítulo 5.

Pergunta 5: Quando precisa estar pronto?

Esta é a pergunta esquecida. Uma série recém-anunciada pode não ter suporte estável no ESP-IDF, não ter core Arduino, não ter módulo à venda e não ter placa de desenvolvimento acessível. Para trabalho com prazo, prefira séries com pelo menos um ano de estrada.

Atalhos por perfil de projeto

ESP-IDF ou Arduino?

Escolhida a série, falta escolher a ferramenta. As duas são oficiais e mantidas pela Espressif; a diferença é o nível de controle.

Vamos montar o "olá mundo" dos sensores: ler temperatura e umidade do ambiente e imprimir no monitor serial. O DHT11 é barato, comum e usa um protocolo digital próprio de um único fio, o que já ensina algo além de acender um LED.

Lista de material

Montagem

1. O ESP32 puxa a linha para baixo por cerca de 18 ms, que é o "acorda" do sensor.
2. Solta a linha; o pull-up a leva para alto.
3. O DHT11 responde puxando para baixo por 80 µs e soltando por mais 80 µs.
4. Em seguida envia 40 bits: umidade (2 bytes), temperatura (2 bytes) e um byte de verificação.
5. Cada bit é codificado pela duração do nível alto: cerca de 26 µs é zero, cerca de 70 µs é um.

A biblioteca mede esses tempos e confere o byte de verificação. Se a soma não bater, seja por ruído, fio solto ou falta de pull-up, ela devolve NaN, e é isso que o nosso código testa.

Passo a passo

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

#include <DHT.h>

#define PINO_DHT  12       // fio amarelo
#define TIPO_DHT  DHT11

DHT dht(PINO_DHT, TIPO_DHT);

void setup() {
  Serial.begin(115200);
  delay(1000);              // tempo para a USB enumerar
  dht.begin();
  Serial.println("Leitor DHT11 - ESP32-S3");
}

void loop() {
  float umidade     = dht.readHumidity();
  float temperatura = dht.readTemperature();

  if (isnan(umidade) || isnan(temperatura)) {
    Serial.println("Falha na leitura do sensor");
  } else {
    Serial.printf("Temperatura: %.1f C | Umidade: %.1f %%\n",
                  temperatura, umidade);
  }

  delay(2000);              // DHT11 nao aceita leitura mais rapida
}

Leitor DHT11 - ESP32-S3
Temperatura: 26.0 C | Umidade: 61.0 %
Temperatura: 26.0 C | Umidade: 61.0 %
Temperatura: 26.1 C | Umidade: 62.0 %

Quando não funciona

Desafios

Se sobrar tempo na formação, ou para praticar depois:

1. Acenda o LED RGB da placa em vermelho quando a temperatura passar de 28 °C e em azul abaixo disso.
2. Calcule e imprima a média das últimas dez leituras, para suavizar o ruído.
3. Troque o delay por controle de tempo com millis(), de modo que o programa continue respondendo enquanto espera.
4. Detecte e conte quantas vezes a umidade subiu mais de 5 % entre leituras consecutivas.
5. Publique a leitura numa página web servida pelo próprio ESP32, acessível por qualquer aparelho na mesma rede.

Glossário

Onde consultar

Por onde continuar

Com o sensor funcionando, o caminho natural é tirar o dado da bancada. Na ordem que costuma render mais aprendizado por hora investida:

1. Conectar ao Wi-Fi e servir uma página com a leitura. É o exercício que mais amarra os conceitos: rede, memória e o laço principal disputando espaço.
2. Publicar em um broker MQTT, que é o protocolo padrão de IoT e o que permite o dado chegar a um painel ou a outro dispositivo.
3. Economizar energia com deep sleep, medindo de verdade quanto tempo uma bateria aguenta.
4. Atualizar o firmware pelo ar com OTA, fechando o ciclo de um produto que não precisa mais de cabo depois de instalado.
5. Migrar um projeto para o ESP-IDF, para enxergar o que o core Arduino estava escondendo.

Material produzido para a LASER, Liga Acadêmica de Sistemas Embarcados do Centro de Informática da UFPE. Dados técnicos conferidos nos datasheets oficiais da Espressif e nas definições de hardware do ESP-IDF. Este é um material independente, sem vínculo com a Espressif Systems.