ESP32

O que é

O ESP32 é um microcontrolador que parece um Arduino com um rádio preso e os freios removidos. Ele tem um processador de dois núcleos de 32 bits que funciona muitas vezes mais rápido que um Uno, muito mais memória e—o recurso principal—Wi-Fi e Bluetooth integrados. Essa combinação explica sua dominância na robótica de iniciação e na IoT: um robô pode servir uma página na Internet para se controlar, transmitir dados de sensores ao celular ou receber comandos por Bluetooth, tudo a partir de um único chip barato.

O mais importante é que você o programa com o mesmo Arduino IDE e a mesma linguagem que talvez já conheça. O que aprendeu em um Uno é transferido diretamente; você simplesmente ganha conectividade e margem de desempenho.

Como funciona

Em seu interior há duas CPUs Xtensa com frequência de até 240 MHz. Ter dois núcleos importa para robôs: um núcleo pode executar a malha de controle com temporização estável enquanto o outro lida com o Wi-Fi, portanto a rede nunca interrompe o controle das rodas. Ao redor da CPU estão os periféricos usuais de um microcontrolador—GPIO, canais PWM, vários ADCs, I²C, SPI e UART—além do rádio.

O fato prático mais importante é a tensão: o ESP32 opera com nível lógico de 3,3 V, não os 5 V do Uno. Seus pinos não toleram 5 V. A saída de 5 V de um sensor—como o pino Echo de um HC-SR04—precisa ser reduzida a 3,3 V antes de tocar em um pino do ESP32, ou você pode danificá-lo. Essa única diferença confunde quase todo mundo que migra de um Uno.

Quando usar

Use um ESP32 quando o robô precisar ser sem fio—controle remoto, telemetria, painel no navegador—ou quando precisar de processamento que uma placa de 8 bits não consegue oferecer, como tratar mais sensores ou executar lógica leve no dispositivo. A variante ESP32-CAM acrescenta uma câmera e permite projetos simples de visão.

Fique com um Arduino Uno quando estiver aprendendo os fundamentos, quando a tolerância a 5 V tornar a ligação mais segura ou quando o projeto for simples e sem conexão— dirigir alguns motores ao longo de uma linha não precisa de Wi-Fi.

Conexões e armadilhas

• Opera a 3,3 V e não tolera 5 V. Faça a conversão de nível de qualquer sinal de 5 V antes que ele chegue a um GPIO. Essa é a causa mais comum de danos causados por iniciantes.
• Wi-Fi mais motores pode causar queda de tensão na placa. O rádio consome picos de corrente agudos; compartilhar uma fonte fraca com os motores provoca reinícios. Alimente os motores separadamente por um driver de motor e forneça ao ESP32 uma trilha estável de 3,3 V.
• Nem todo pino está livre. Vários GPIOs são apenas de entrada, estão ligados ao comportamento de inicialização ou conectados à flash interna. Verifique a pinagem antes de atribuir pinos, ou a placa não inicializará.
• Particularidades do ADC. Um dos dois ADCs fica indisponível enquanto o Wi-Fi está ativo, e as leituras são menos lineares que as de um Uno—calibre se precisar de precisão.

Os pinos que você não deve usar

Um ESP32 tem cerca de 34 GPIOs, e isso é enganoso, pois um número significativo deles é inutilizável, utilizável apenas sob condições ou faz a placa deixar de inicializar. Esta tabela é a coisa mais importante a ler antes de conectar qualquer coisa.

Os pinos de uso geral mais seguros em uma placa padrão de 30 pinos são GPIO 4, 5, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 32 e 33. Comece por eles e evitará todas as armadilhas acima.

Os pinos de modo de inicialização causam a falha mais confusa, porque a placa funciona perfeitamente até você conectar alguma coisa. Um resistor de pull-up no GPIO 12—totalmente razoável para um botão—faz a placa simplesmente não iniciar, sem erro e sem saída serial.

Os pinos somente de entrada confundem de outra forma: GPIO 34–39 não têm pull-up nem pull-down interno, então um botão conectado a um deles flutua e produz leituras aleatórias. Eles precisam de um resistor externo.

3,3 V e o que isso custa

Os pinos do ESP32 não toleram 5 V, e essa é a causa mais comum de danificá-lo. Qualquer sinal de 5 V precisa de tratamento:

Vale ter esta assimetria em mente: as saídas normalmente são seguras; as entradas, não. O pino Echo de um HC-SR04 é o caso clássico—ele produz 5 V completos em um pino especificado para 3,6 V de máximo absoluto.

O problema do ADC

O ADC do ESP32 é a parte mais fraca do chip, e fingir o contrário desperdiça horas.

O ADC2 não funciona enquanto o Wi-Fi está ativo. O rádio o utiliza. Qualquer analogRead em um pino ADC2 retorna valores inválidos ou bloqueia no instante em que o Wi-Fi conecta—e, como um robô sem fio é justamente a razão para usar um ESP32, isso praticamente elimina o ADC2. Use somente o ADC1: GPIO 32–39.

A resposta não é linear. O ADC de 12 bits é claramente não linear nas duas extremidades, e leituras abaixo de aproximadamente 0,1 V e acima de cerca de 3,1 V são comprimidas. O chip contém dados de calibração de fábrica que as funções esp_adc_cal do ESP-IDF aplicam; o analogRead do Arduino não os usa por padrão.

Se você precisa de precisão real de um sensor analógico, a resposta prática é um ADC I²C externo, como o ADS1115. Custa poucos dólares e elimina todo o problema.

Alimentando sem quedas de tensão

É aqui que a maioria dos projetos de robô com ESP32 falha, e a causa não é óbvia.

O rádio não consome uma corrente constante—ele a consome em rajadas. Uma rajada de transmissão pode consumir 500 mA por algumas centenas de microssegundos, contra uma média de 40–80 mA. Uma fonte que parece correta no multímetro ainda pode cair nesses picos, e o ESP32 responde reiniciando com a mensagem Brownout detector was triggered.

Vale deixar este último ponto bem claro: aplique 5 V ao pino VIN/5V e deixe o regulador da placa gerar 3,3 V. Injetar 3,3 V diretamente contorna o regulador e sua filtragem, que é justamente o que se quer dele.

Dois núcleos e como usá-los de verdade

O núcleo duplo é a vantagem real do ESP32 para robôs, e a estrutura do Arduino a oculta—seu loop() é executado no núcleo 1, enquanto a pilha Wi-Fi roda no núcleo 0.

Você pode fixar uma tarefa em um núcleo explicitamente:

void controlLoop(void *param) {
  const TickType_t period = pdMS_TO_TICKS(10);   // exactly 100 Hz
  TickType_t last = xTaskGetTickCount();
  for (;;) {
    readSensors();
    updatePid();
    driveMotors();
    vTaskDelayUntil(&last, period);              // no drift, unlike delay()
  }
}

void setup() {
  xTaskCreatePinnedToCore(
    controlLoop, "control", 4096, nullptr,
    2,          // priority above the default
    nullptr,
    1);         // core 1 — leave core 0 for Wi-Fi
}

Este é o padrão que torna um ESP32 realmente bom para robôs, e não apenas para projetos conectados: uma malha de controle com temporização rígida em um núcleo e um servidor HTTP no outro que não consegue interrompê-la. vTaskDelayUntil é o detalhe importante—diferente de delay(), ele compensa qualquer tempo que o corpo do laço tenha demorado, portanto o período permanece exatamente 10 ms.

Solução de problemas

ESP32 ou Arduino Uno?

Ambos usam a mesma linguagem e o mesmo IDE, que é o ponto—a transição custa quase nada em código e bastante em disciplina de ligação.

A recomendação honesta é: aprenda em um Uno, construa em um ESP32. A tolerância a 5 V do Uno e a ausência completa de armadilhas de pinos tornam recuperáveis seus erros iniciais. Depois que souber o que é uma malha de controle e por que as massas precisam ser comuns, o ESP32 oferece quinze vezes a frequência de operação, 260 vezes a memória e um rádio por aproximadamente o mesmo preço.

A variante ESP32-CAM merece ser conhecida separadamente: acrescenta uma câmera e um slot SD por poucos dólares, e é de longe o caminho mais barato para a visão robótica—ao custo de quase não sobrar GPIO livre.