Arduino ou ESP32: principais diferenças e qual escolher

Arduino ou ESP32? A resposta curta é esta: se o seu projeto precisa de Wi-Fi, Bluetooth, internet ou bastante poder de processamento, escolha o ESP32; se você está aprendendo o básico de eletrônica, quer usar sensores e módulos de 5 V sem complicação e seguir qualquer tutorial ao pé da letra, escolha o Arduino Uno. As duas placas são programadas na Arduino IDE com os mesmos comandos digitalWrite, analogRead e Serial. A diferença real está no hardware: velocidade, memória, tensão de operação, pinos e conectividade sem fio.

Neste guia comparamos o Arduino Uno R3 com a placa ESP32 mais comum, a ESP32 DevKit (com o módulo ESP-WROOM-32), usando números reais: o que as diferenças de CPU e memória significam na prática, quais módulos são afetados por 5 V contra 3,3 V, como mudam a entrada analógica e o PWM, e quantas horas cada uma dura na bateria? Depois vamos rodar o mesmo sketch nas duas placas, dar uma olhada rápida no Raspberry Pi Pico e resumir em uma tabela qual placa escolher para cada tipo de projeto.

Resposta curta: qual escolher e quando?

O que são o Arduino Uno e o ESP32?

O Arduino Uno R3 é a placa mais conhecida da plataforma Arduino, desenvolvida na Itália. No coração dele está o microcontrolador de 8 bits ATmega328P, rodando a 16 MHz. A placa funciona em 5 V e a disposição dos pinos não muda há anos, então centenas de shields (placas de expansão que encaixam por cima), livros e cursos são compatíveis com ela. O projeto simples deixa você ver exatamente o que está acontecendo: quando você escreve HIGH em um pino, há de fato 5 V nele. O Uno R4, mais novo, vem com um processador Arm de 32 bits a 48 MHz e 32 KB de RAM, e a versão R4 WiFi acrescenta um ESP32-S3 à placa para a conectividade sem fio; neste artigo, “Uno” significa o R3, que ainda é o mais comum. Para conhecer melhor a plataforma, leia O que é Arduino?.

Já o ESP32 é um sistema em um chip (SoC) de 32 bits lançado pela Espressif em 2016, com Wi-Fi e Bluetooth no mesmo chip. A placa que você tem na mão é uma placa de desenvolvimento que carrega esse chip: ela tem um conversor USB-serial, um regulador de 3,3 V e os botões EN e BOOT. Um detalhe importante: o ESP32 não é um Arduino, mas, graças ao core Arduino feito pela Espressif, ele é programado na Arduino IDE como se fosse um. Para a configuração e os primeiros projetos, O que é ESP32? é um bom ponto de partida.

A grande tabela comparativa: Arduino Uno, ESP32 e Raspberry Pi Pico

CPU e memória: o que os números significam na prática?

O processador do Uno executa cerca de 16 milhões de instruções por segundo e trabalha com números de 8 bits por vez; uma operação com long ou float de 32 bits leva dezenas de instruções, e não há unidade de ponto flutuante (FPU) em hardware. O ESP32 roda a 240 MHz com números de 32 bits e tem uma FPU de precisão simples. Por isso, em um cálculo cheio de float, o ESP32 pode ser dezenas ou até centenas de vezes mais rápido que o Uno. Você não vai notar a diferença piscando um LED ou lendo um sensor algumas vezes por segundo, mas ela se torna decisiva em filtragem, processamento de áudio, criptografia ou no cálculo de animações para centenas de LEDs. Uma dica: a FPU do ESP32 só cuida de float; operações com double rodam em software e são bem mais lentas.

Na diferença de memória você vai esbarrar com muito mais frequência. Os 2 KB de RAM do Uno são divididos entre suas variáveis, os buffers da Serial e o espaço que as bibliotecas reservam. Quando a RAM acaba, o compilador geralmente não avisa; o programa trava aleatoriamente ou se comporta de um jeito estranho. Situações típicas em que o Uno fica sem RAM rapidinho:

• Display OLED: só o buffer de quadro de um display SSD1306 de 128×64 ocupa 1 KB, metade da RAM (veja display OLED de 0,96 polegada).
• LEDs endereçáveis: cada LED WS2812B ocupa 3 bytes, então uma fita de 300 LEDs precisa de 900 bytes (veja WS2812B NeoPixel).
• Dados da internet: o JSON devolvido por um serviço de previsão do tempo pode ter vários KB; não cabe no Uno, mas é fácil de tratar no ESP32.
• Concatenação de String: objetos String que crescem sem parar dentro de um loop fragmentam a pouca RAM e podem causar um travamento horas depois.
• Cartão SD: a biblioteca SD reserva um buffer de setor de 512 bytes; junto com bibliotecas de display e de sensor, você chega ao limite rapidinho.

A diferença de tensão: 5 V vs 3,3 V

Esta é a diferença mais ignorada. Os pinos do Uno usam lógica de 5 V: uma saída HIGH dá 5 V, e entradas acima de 3 V contam como HIGH. Os pinos do ESP32 usam lógica de 3,3 V e não toleram 5 V. Aplicar 5 V em um pino pode não matar o ESP32 na hora, mas força os diodos de proteção internos e pode destruir o chip com o tempo ou de uma vez. A outra direção é menos problemática: o sinal HIGH de 3,3 V do ESP32 mal passa do limiar de 3 V do Uno, então costuma ser lido como HIGH, mas isso também não conta como um projeto seguro. Veja como os módulos comuns se comportam com cada placa:

Pinos, entrada analógica e PWM

No Uno, os 20 pinos se comportam mais ou menos do mesmo jeito: cada um pode ser entrada ou saída, fornece tranquilamente até 20 mA e não afeta a inicialização. A ESP32 DevKit tem mais pinos no papel, mas eles não são todos iguais: os GPIO 6–11 estão ligados à flash interna e não podem ser usados, os GPIO 34–39 são só de entrada e os GPIO 0, 2, 5, 12 e 15 precisam estar em certos níveis durante a inicialização. Na prática você usa com tranquilidade uns 20–25 pinos. O mapa de pinos da sua placa está na ferramenta de pinagem.

Na entrada analógica, o ADC de 10 bits do Uno divide a faixa de 0–5 V em 1024 passos; cada passo tem cerca de 4,9 mV, e as leituras são bem lineares. O ADC de 12 bits do ESP32 dá 4096 passos, mas, no ajuste padrão, não distingue valores abaixo de cerca de 0,15 V nem acima de 3,1 V, tem ruído, e os pinos do ADC2 não funcionam enquanto o Wi-Fi está ligado. Se você precisa de uma tensão precisa no ESP32, use analogReadMilliVolts() e ligue o sensor nos pinos do ADC1 (GPIO 32–39). No PWM o ESP32 sai na frente: enquanto o Uno oferece PWM de 8 bits em só 6 pinos, a 490 ou 980 Hz, o ESP32 consegue direcionar 16 canais com frequência e resolução ajustáveis para quase qualquer pino de saída. Ele também tem 2 DACs (GPIO 25 e 26) que geram uma tensão analógica de verdade. Para o básico de PWM, veja O que é PWM?.

O mesmo sketch nas duas placas: o que muda?

A boa notícia: tudo o que você aprendeu no Arduino vale também para o ESP32. O sketch abaixo lê um potenciômetro, mostra a tensão no Monitor Serial e acende o LED da placa quando o valor passa da metade. A linha #if defined(ESP32) detecta para qual placa o código está sendo compilado e muda só o número do pino, a tensão de referência e a resolução do ADC. Ligue as pernas externas do potenciômetro em 5V e GND no Uno, ou em 3V3 e GND no ESP32; ligue a perna do meio em A0 no Uno ou no GPIO 34 no ESP32 e abra o Monitor Serial em 115200 baud. As principais diferenças fora do código estão na tabela.

1// Aynı kod Uno ve ESP32'de çalışır / The same sketch runs on Uno and ESP32
2#if defined(ESP32)
3const int LED_PIN = 2;        // DevKit dahili LED / DevKit onboard LED
4const int POT_PIN = 34;       // ADC1 pini, Wi-Fi ile de çalışır / ADC1 pin, works with Wi-Fi too
5const float VREF = 3.3;       // ESP32 pinleri 3,3 V / ESP32 pins are 3.3 V
6const int ADC_MAX = 4095;     // 12 bit
7#else
8const int LED_PIN = 13;       // Uno dahili LED / Uno onboard LED
9const int POT_PIN = A0;
10const float VREF = 5.0;       // Uno referansı 5 V / Uno reference is 5 V
11const int ADC_MAX = 1023;     // 10 bit
12#endif
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17}
18
19void loop() {
20  int raw = analogRead(POT_PIN);
21  float volts = raw * VREF / ADC_MAX;
22  Serial.print("Ham / raw: ");
23  Serial.print(raw);
24  Serial.print("  Gerilim / voltage: ");
25  Serial.println(volts, 2);
26  digitalWrite(LED_PIN, raw > ADC_MAX / 2 ? HIGH : LOW);   // yarıdan fazlaysa LED yanar / LED on above half
27  delay(250);
28}

Wi-Fi, Bluetooth e internet

O que realmente diferencia o ESP32 é a conectividade sem fio. A placa entra em redes Wi-Fi de 2,4 GHz, pode criar o próprio ponto de acesso, roda um servidor web, envia dados para um sistema de casa inteligente via MQTT, pega a hora da internet por NTP e pode atualizar o firmware sem fio (OTA). No lado do Bluetooth, tanto o Bluetooth clássico (Serial Port Profile) quanto o BLE de baixo consumo são suportados, e com o ESP-NOW vários ESP32 conversam entre si sem roteador. Nada disso vem embutido no Uno: para Bluetooth você precisa de um módulo como o módulo Bluetooth HC-05, e para Wi-Fi, de um chip separado como o ESP-01 mais comandos AT. O sketch abaixo lê o mesmo potenciômetro, agora via Wi-Fi: abra o endereço mostrado no Monitor Serial no navegador de um celular na mesma rede e você vai ver a tensão em milivolts, com a página se atualizando sozinha a cada dois segundos.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
6const int POT_PIN = 34;              // ADC1 pini / ADC1 pin
7
8WebServer server(80);
9
10void handleRoot() {
11  uint32_t mv = analogReadMilliVolts(POT_PIN);   // kalibre edilmiş mV / calibrated mV
12  String html = "<meta name='viewport' content='width=device-width'>"
13                "<meta http-equiv='refresh' content='2'>"
14                "<h1>ESP32</h1><p>Pot: ";
15  html += mv;
16  html += " mV</p>";
17  server.send(200, "text/html", html);
18}
19
20void setup() {
21  Serial.begin(115200);
22  WiFi.begin(ssid, password);
23  while (WiFi.status() != WL_CONNECTED) delay(500);
24  Serial.print("Telefonda aç / open on your phone: http://");
25  Serial.println(WiFi.localIP());
26  server.on("/", handleRoot);
27  server.begin();
28}
29
30void loop() {
31  server.handleClient();
32}

Consumo de energia e funcionamento com bateria

No papel, o ESP32 é ao mesmo tempo a placa mais gulosa e a mais econômica. Enquanto envia dados por Wi-Fi, ele puxa picos de até 240 mA, e é por isso que reinicia com o erro “Brownout detector was triggered” em uma porta USB fraca. Em deep sleep, por outro lado, o chip usa só cerca de 10 µA. A placa Uno puxa cerca de 45 mA sem fazer nada; mesmo com o ATmega328P dormindo, o chip USB-serial, o regulador e o LED de energia continuam consumindo uns 30 mA. Vamos a um exemplo: uma bateria de 2000 mAh alimenta um Uno funcionando sem parar por cerca de 2000 / 45 ≈ 44 horas. Um ESP32 com o Wi-Fi sempre ligado (100 mA em média) dura cerca de 20 horas. Mas, se o ESP32 acordar a cada 10 minutos por 3 segundos, enviar uma leitura a 120 mA e dormir a 10 µA nos 597 segundos restantes, a corrente média é (3 × 120 + 597 × 0,01) / 600 ≈ 0,61 mA, e a mesma bateria dura, em teoria, mais de 3000 horas, ou seja, mais de quatro meses. Esse resultado exige uma placa de baixo consumo ou um módulo puro; o regulador e o chip USB das DevKits comuns puxam alguns mA mesmo dormindo. Você pode calcular o seu próprio cenário com a ferramenta de duração da bateria.

Onde entra o Raspberry Pi Pico?

A terceira opção forte é o Raspberry Pi Pico. O chip RP2040 tem dois núcleos Cortex-M0+ de 133 MHz, 264 KB de RAM e 2 MB de flash, e custa cerca de US$ 4. Como o ESP32, funciona em 3,3 V e oferece 26 GPIOs, mas tem só 3 entradas analógicas. Os maiores pontos fortes dele são o suporte muito maduro ao MicroPython, o carregamento fácil de firmware, aparecendo no computador como um pen drive, e as unidades chamadas PIO, que geram protocolos com temporização precisa sem carregar o processador. Se você quer conexão sem fio, escolha o Pico W (Wi-Fi e Bluetooth); para mais potência, o Pico 2, com o chip RP2350. Mais detalhes em O que é Raspberry Pi Pico?. A mesma leitura do potenciômetro fica assim no Pico em MicroPython (perna do meio no GP26, pernas externas em 3V3 e GND):

1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                  # GP26 = ADC0, potansiyometre orta ucu / pot wiper
5led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6
7while True:
8    raw = pot.read_u16()                   # 0–65535 (12 bit ölçüm ölçeklenir / 12-bit reading, scaled)
9    volts = raw * 3.3 / 65535
10    print("Ham / raw:", raw, " Gerilim / voltage: {:.2f}".format(volts))
11    led.value(raw > 32767)                 # yarıdan fazlaysa yanar / on above half
12    time.sleep(0.25)

Preço e facilidade de aprendizado

O preço sozinho raramente decide. Um Uno R3 original custa cerca de US$ 25–30, enquanto os clones com o chip USB CH340 saem por US$ 5–10; as ESP32 DevKits clones custam US$ 4–8 e o Pico, US$ 4. Então quase não há diferença de preço entre um ESP32 e um clone do Uno; o custo real aparece nos extras: usar módulos de 5 V com o ESP32 pede alguns resistores ou um conversor de nível de US$ 1–2, e colocar Wi-Fi no Uno pede um módulo separado. No aprendizado, o Uno sai na frente: você escolhe a placa e clica em Carregar, as mensagens de erro e os exemplos são os mesmos há anos e não há incompatibilidade de tensão com módulos de 5 V. No ESP32 você primeiro instala o pacote de placas da Espressif e, se precisar, o driver do chip USB (CP2102 ou CH340), escolhe o modelo certo da placa e, em algumas placas, segura o botão BOOT durante o carregamento; além disso, alguns exemplos da internet foram escritos para versões antigas do core e podem não compilar (no core 3.x, por exemplo, ledcAttach substitui o ledcSetup). Esses obstáculos levam algumas horas para vencer, mas, se você está montando circuitos pela primeira vez, no Uno é mais fácil saber se um problema vem do código ou da ligação.

Qual placa para qual projeto?

Erros e mal-entendidos comuns

• “O ESP32 é sempre melhor”: ele é mais potente, mas os pinos de 3,3 V, os pinos sensíveis na inicialização, o botão BOOT e as quedas de alimentação podem cansar um iniciante. Para aprender o básico, o Uno traz menos surpresas.
• Ligar um sensor de 5 V direto no ESP32: ligar sinais de 5 V, como a saída ECHO do HC-SR04, sem divisor pode danificar o pino.
• Ler um pino do ADC2 com o Wi-Fi ligado: os GPIO 0, 2, 4, 12–15 e 25–27 não leem valores analógicos enquanto o Wi-Fi está funcionando; mude o sensor para os GPIO 32–39.
• Esquecer a RAM do Uno: se o código compila mas a placa trava aleatoriamente, a RAM pode ter acabado; coloque os textos fixos dentro de F("...") e evite concatenar Strings em um loop.
• Alimentar o ESP32 por uma USB fraca: se a placa reinicia quando o Wi-Fi liga, use um bom cabo de dados e uma fonte que forneça pelo menos 1 A.
• Confundir o Pico com o Pico W: o Pico comum não tem Wi-Fi; para um projeto sem fio, compre o modelo com W no nome.

Resumindo: o Arduino Uno é a placa para aprender, o ESP32 é a placa para conectar e o Raspberry Pi Pico é a placa para experimentar com Python. Se você está em dúvida sobre qual modelo da família Arduino combina com você, dê uma olhada em Qual Arduino comprar?. No app BlueGrays você encontra dezenas de projetos para Arduino, ESP32 e Pico, de piscar um LED a um servidor web com Wi-Fi e de um relógio NTP a um display de previsão do tempo, cada um com esquema do circuito e código passo a passo.