ESP32 30 pinos vs 38 pinos: pinagem, protoboard, WROOM, CP2102
ESP32 30 pinos vs 38 pinos: pinagem lado a lado, por que não cabe na protoboard, WROOM vs WROVER, CP2102 vs CH340 e qual placa escolher na Arduino IDE.
A diferença entre uma placa ESP32 de 30 pinos e uma de 38 pinos é menor do que parece: as duas costumam ter o mesmo módulo ESP32-WROOM-32, rodam o mesmo código e são configuradas como "ESP32 Dev Module" na Arduino IDE. A placa de 38 pinos expõe oito pinos a mais: o GPIO 0, os GPIO 6–11 (ligados à memória flash) e mais um GND. Como os pinos da flash não podem ser usados de qualquer forma, a diferença real costuma se resumir ao GPIO 0, à ordem dos pinos na placa e a como ela fica na protoboard.

Neste artigo colocamos as duas pinagens lado a lado, explicamos por que essas placas não cabem bem na protoboard e como resolver, decodificamos as marcações WROOM e WROVER na blindagem metálica, mostramos como saber se o seu chip USB é um CP2102 ou um CH340 e passamos pelos ajustes da Arduino IDE passo a passo. No fim há um sketch de teste que mostra o modelo do chip, o tamanho da flash e a PSRAM da sua placa.
Qual é a diferença entre as placas ESP32 de 30 e de 38 pinos?
O próprio módulo ESP32-WROOM-32 tem 38 pontos de solda. O fabricante da placa de desenvolvimento decide quais deles levar às barras de pinos nas bordas. A ESP32-DevKitC da própria Espressif e os clones dela oferecem 2×19 pinos, um para cada ponto do módulo. A DOIT ESP32 DevKit V1 e placas parecidas deixam de fora os pinos arriscados da flash e o GPIO 0 (o pino do botão BOOT) e se viram com 2×15 = 30 pinos. Ou seja, a placa de 38 pinos não é mais potente; ela só expõe mais pontos.
| Característica | Placa de 30 pinos (DevKit V1) | Placa de 38 pinos (DevKitC e clones) |
|---|---|---|
| Módulo | Normalmente ESP32-WROOM-32 / 32D / 32E | ESP32-WROOM-32 / 32E, algumas com WROVER |
| Disposição das barras | 2 × 15 | 2 × 19 |
| GPIOs expostos | 25 | 32 (6 são pinos da flash) |
| GPIOs realmente utilizáveis | 25 | 26 |
| GPIO 0 | Não está em um pino, só no botão BOOT | Disponível como pino |
| Pinos da flash (GPIO 6–11) | Não | Sim (CLK, SD0–SD3, CMD), não utilizáveis |
| Pinos GND | 2 | 3 |
| Pinos de alimentação | VIN e 3V3 | 5V e 3V3 |
| LED do usuário | A maioria tem um LED azul no GPIO 2 | Nenhum na placa da Espressif, GPIO 2 em alguns clones |
| Placa na Arduino IDE | ESP32 Dev Module ou DOIT ESP32 DEVKIT V1 | ESP32 Dev Module |
A conclusão da tabela é simples: você nunca vai usar em nenhum projeto seis dos pinos extras da placa de 38 pinos, então o único ganho real é o GPIO 0. Por isso "mais pinos é placa melhor" não vale para o ESP32. A sua escolha deve depender não do número de pinos, e sim da organização da sua protoboard, dos esquemas de ligação que você vai seguir e da placa de expansão que pretende usar.
Pinagem: onde fica cada pino nas duas placas?
A tabela abaixo mostra a ordem dos pinos de cima para baixo, com a antena em cima, a porta USB embaixo e os componentes virados para você. As placas DevKit V1 marcam os pinos como "D23" ou "TX2"; lembre que no código você escreve o número do GPIO (23, 17), não a marcação. Você também vê o mapa completo da sua placa na ferramenta Pinout.
| Posição | 30 pinos, esquerda | 30 pinos, direita | 38 pinos, esquerda | 38 pinos, direita |
|---|---|---|---|---|
| 1 | EN | D23 | 3V3 | GND |
| 2 | VP (GPIO 36) | D22 | EN | GPIO 23 |
| 3 | VN (GPIO 39) | TX0 (GPIO 1) | SVP (GPIO 36) | GPIO 22 |
| 4 | D34 | RX0 (GPIO 3) | SVN (GPIO 39) | TX (GPIO 1) |
| 5 | D35 | D21 | GPIO 34 | RX (GPIO 3) |
| 6 | D32 | D19 | GPIO 35 | GPIO 21 |
| 7 | D33 | D18 | GPIO 32 | GND |
| 8 | D25 | D5 | GPIO 33 | GPIO 19 |
| 9 | D26 | TX2 (GPIO 17) | GPIO 25 | GPIO 18 |
| 10 | D27 | RX2 (GPIO 16) | GPIO 26 | GPIO 5 |
| 11 | D14 | D4 | GPIO 27 | GPIO 17 |
| 12 | D12 | D2 | GPIO 14 | GPIO 16 |
| 13 | D13 | D15 | GPIO 12 | GPIO 4 |
| 14 | GND | GND | GND | GPIO 0 |
| 15 | VIN | 3V3 | GPIO 13 | GPIO 2 |
| 16 | - | - | SD2 (GPIO 9) | GPIO 15 |
| 17 | - | - | SD3 (GPIO 10) | SD1 (GPIO 8) |
| 18 | - | - | CMD (GPIO 11) | SD0 (GPIO 7) |
| 19 | - | - | 5V | CLK (GPIO 6) |
Os lados esquerdos são bem parecidos, mas os direitos não: a placa de 30 pinos tem GND e 3V3 no canto inferior direito, enquanto a de 38 pinos tem o GPIO 0, o 2, o 15 e os pinos da flash na mesma região. Então, se você montar um esquema desenhado para uma placa copiando "a mesma posição" na outra, vai ligar nos pinos errados. A ordem pode variar um pouco nos clones; guie-se sempre pelas marcações impressas na sua placa.
O problema do encaixe na protoboard e como resolvê-lo
Uma protoboard padrão tem cinco furos ligados de cada lado de cada fileira (a–e e f–j), com um canal no meio. A placa ESP32 fica sobre o canal e cobre tudo entre as suas duas barras de pinos. Placas com 22,86 mm (0,9 polegada) entre as fileiras de pinos deixam um furo livre de cada lado. Placas com 25,4 mm (1 polegada) deixam um único furo só de um lado, e do outro lado não dá para encaixar nem um fio nos pinos. A largura depende do fabricante; você encontra as duas larguras entre placas de 30 e de 38 pinos, mas a larga é a mais comum. Se já tem a placa, meça com uma régua a distância entre as duas fileiras de pinos; antes de comprar, confira as dimensões do produto.
- Duas protoboards lado a lado: tire a tira de alimentação da borda de uma delas, junte as duas protoboards e coloque uma fileira de pinos da placa em cada uma. Você fica com cinco furos ao lado de cada pino; é a solução mais fácil e barata.
- Jumpers fêmea-macho: deixe a placa fora da protoboard e ligue direto nos pinos com fios de ponta fêmea. É rápido para testes pequenos, mas os fios soltam com facilidade.
- Placa de expansão (base breakout): essas bases com bornes de parafuso, ou com GND e 3V3 ao lado de cada pino, tiram a protoboard da jogada. Elas são feitas separadamente para placas de 30 e de 38 pinos, então compre a que combina com o número de pinos e a largura da sua placa.
- Escolha uma placa estreita: se você vai trabalhar muito em protoboard, escolha uma placa com 22,86 mm entre as fileiras de pinos. Se a página do produto não trouxer essa medida, pergunte ao vendedor.
WROOM vs WROVER: o que a blindagem metálica diz?
A etiqueta no módulo com blindagem metálica mostra o nome do modelo. Os módulos WROOM contêm só o processador e a memória flash. Os módulos WROVER são um pouco mais compridos e incluem também uma RAM externa chamada PSRAM. Os modelos com "U" (como WROOM-32U ou WROVER-IE) não têm antena PCB; no lugar dela há um minúsculo conector U.FL para antena externa. O D ou E no fim do nome indica a versão do chip interno.
| Módulo | Chip | Flash | PSRAM | Observação |
|---|---|---|---|---|
| ESP32-WROOM-32 | ESP32-D0WDQ6 | 4 MB | Nenhuma | A primeira versão; comum em placas mais antigas e baratas |
| ESP32-WROOM-32D | ESP32-D0WD | 4 MB (existem opções de 8 e 16 MB) | Nenhuma | O modelo mais comum por anos |
| ESP32-WROOM-32E | ESP32-D0WD-V3 | 4, 8 ou 16 MB | Nenhuma | Placas mais novas; o silício V3 corrige bugs do chip anterior |
| ESP32-WROOM-32U / 32UE | Igual ao WROOM-32D / 32E | 4 MB ou mais | Nenhuma | Conector U.FL para antena externa |
| ESP32-WROVER-E / IE | ESP32-D0WD-V3 | 4, 8 ou 16 MB | 2 ou 8 MB | Módulo mais comprido; GPIO 16 e 17 reservados à PSRAM |
Para quase todo projeto, como ler sensores, acionar um relé, rodar um servidor web ou mandar alertas no Telegram, um WROOM é tudo de que você precisa; os 520 KB de RAM interna do ESP32 sobram para isso. A PSRAM faz diferença em tarefas que consomem muita memória, como imagens de câmera, interfaces gráficas em displays coloridos grandes ou gravação de áudio. Para usar a PSRAM de uma placa WROVER, você precisa ativar PSRAM: Enabled na Arduino IDE; se estiver desativada, a memória nem aparece.
Chip USB-serial: CP2102 ou CH340?
O ESP32 não fala USB sozinho; o pequeno chip logo ao lado da porta USB faz a tradução entre ele e o seu computador. O chip da sua placa decide com que nome ela aparece no computador e de qual driver precisa. Se a marcação do chip for pequena demais para ler, olhe o formato:
| Chip | Aparência | Nome no Windows | USB ID (VID:PID) | Driver |
|---|---|---|---|---|
| CP2102 / CP2104 (Silicon Labs) | Quadrado, sem perninhas (QFN) | Silicon Labs CP210x USB to UART Bridge | 10C4:EA60 | Normalmente automático; senão, o driver CP210x VCP |
| CH340C / CH340G (WCH) | Retangular, com perninhas dos dois lados (SOP-16) | USB-SERIAL CH340 | 1A86:7523 | Normalmente automático; senão, o driver CH341SER |
| CH9102F (WCH) | Quadrado pequeno, sem perninhas (QFN) | USB-Enhanced-SERIAL CH9102 | 1A86:55D4 | Driver CH343SER em sistemas mais antigos |
No Windows, abra o Gerenciador de Dispositivos e olhe em Portas (COM e LPT); o item que aparece ao ligar a placa indica o chip. Se aparecer como "Dispositivo desconhecido", clique com o botão direito, vá em Propriedades > Detalhes > IDs de hardware e compare o VID e o PID com a tabela. As versões recentes do macOS e do Linux reconhecem a maioria desses chips sem driver extra; a porta aparece como /dev/cu.usbserial-... no macOS e /dev/ttyUSB0 no Linux. Nas placas com CH340G você vê um pequeno cristal de 12 MHz ao lado do chip; o CH340C não precisa dele. Para mais sobre drivers e portas, veja Conversor USB-TTL.
Escolhendo a placa e os ajustes certos na Arduino IDE
- No Gerenciador de Placas, procure esp32 e instale o pacote da Espressif Systems. Para uma primeira instalação, siga os passos de O que é o ESP32?.
- Em Ferramentas > Placa > esp32, escolha ESP32 Dev Module. Essa opção funciona com todas as placas WROOM de 30 e de 38 pinos.
- Para a placa de 30 pinos você também pode escolher DOIT ESP32 DEVKIT V1; a única diferença é que ela define a constante LED_BUILTIN como GPIO 2.
- Se a sua placa tem um WROVER, escolha ESP32 Wrover Module, ou coloque a opção PSRAM em Enabled no ESP32 Dev Module.
- Escolha a porta da sua placa em Ferramentas > Porta e carregue. Se o upload travar em "Connecting...", segure o botão BOOT e solte quando o upload começar.
| Ajuste do menu Ferramentas | Valor recomendado | Quando mudar |
|---|---|---|
| Upload Speed | 921600 | 115200 se os uploads pararem no meio |
| CPU Frequency | 240MHz (WiFi/BT) | 80 ou 160 MHz se precisar economizar bateria |
| Flash Mode | QIO | DIO se um clone não iniciar |
| Flash Size | 4MB (32Mb) | O tamanho real em módulos de 8 ou 16 MB |
| Partition Scheme | Default 4MB with spiffs | Huge APP (3MB No OTA) se o seu sketch não couber |
| PSRAM | Disabled | Enabled em placas com módulo WROVER |
Um sketch que identifica a sua placa: modelo, flash e PSRAM
Em vez de adivinhar qual chip, quanta flash e quanta PSRAM a sua placa tem, você pode perguntar à própria placa. Carregue este sketch e abra o Monitor Serial a 115200 baud:
1// Kartını tanı: yonga modeli, flaş, PSRAM ve MAC / Identify your board: chip model, flash, PSRAM and MAC
2void setup() {
3 Serial.begin(115200);
4 delay(1000); // Seri Monitör'ün açılmasını bekle / wait for the Serial Monitor
5
6 Serial.printf("Yonga / Chip: %s, rev %d, %d cekirdek / cores\n",
7 ESP.getChipModel(), ESP.getChipRevision(), ESP.getChipCores());
8 Serial.printf("CPU: %lu MHz\n", (unsigned long)ESP.getCpuFreqMHz());
9 Serial.printf("Flas / Flash: %lu MB\n", (unsigned long)(ESP.getFlashChipSize() / (1024 * 1024)));
10 Serial.printf("PSRAM: %lu KB\n", (unsigned long)(ESP.getPsramSize() / 1024)); // WROOM: 0, WROVER: > 0 (PSRAM: Enabled)
11
12 uint64_t mac = ESP.getEfuseMac(); // fabrikada yazılan MAC / factory MAC
13 Serial.print("MAC: ");
14 for (int i = 0; i < 6; i++) {
15 Serial.printf("%02X", (unsigned int)((mac >> (8 * i)) & 0xFF));
16 if (i < 5) Serial.print(':');
17 }
18 Serial.println();
19}
20
21void loop() {
22}Se a saída disser ESP32-D0WDQ6, o módulo provavelmente é o WROOM-32 original; ESP32-D0WD costuma indicar um WROOM-32D, e ESP32-D0WD-V3 (rev 3) um WROOM-32E ou WROVER-E. Se a linha da PSRAM for maior que zero, a sua placa é um WROVER, mas esse valor só aparece com a opção PSRAM ativada. Se a flash for maior que 4 MB, você pode ajustar o Flash Size para o valor real e abrir espaço para programas maiores. O endereço MAC ajuda a achar a sua placa na lista de dispositivos conectados do roteador.
LED integrado e teste de pinos
A maioria das placas DevKit V1 de 30 pinos tem um LED azul no GPIO 2, separado do LED vermelho de energia que fica aceso enquanto a placa está alimentada. A DevKitC de 38 pinos da Espressif não tem LED do usuário, enquanto alguns clones também põem um no GPIO 2. O sketch abaixo coloca em HIGH, um de cada vez por um segundo, os pinos de saída seguros que existem nas duas placas e mostra no Monitor Serial qual está ativo. Ligue um LED ao GND por um resistor de 220 Ω e encoste a outra perna dele nos pinos para conferir se as marcações da sua placa estão certas.
1// 30 ve 38 pinli kartta ortak, güvenli çıkış pinleri / safe output pins found on both 30- and 38-pin boards
2const int LED_PIN = 2; // DevKit V1 mavi LED; "ESP32 Dev Module" seçiliyken LED_BUILTIN tanımlı değildir
3 // DevKit V1 blue LED; LED_BUILTIN is not defined when "ESP32 Dev Module" is selected
4const int pins[] = {4, 5, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 32, 33}; // WROVER'da 16 ve 17'yi sil / remove 16 and 17 on WROVER
5const int count = sizeof(pins) / sizeof(pins[0]);
6
7void setup() {
8 Serial.begin(115200);
9 pinMode(LED_PIN, OUTPUT);
10 for (int i = 0; i < count; i++) pinMode(pins[i], OUTPUT);
11}
12
13void loop() {
14 for (int i = 0; i < count; i++) {
15 Serial.printf("GPIO %d -> HIGH\n", pins[i]); // LED + 220 Ω ile bu pini yokla / probe this pin with an LED + 220 Ω
16 digitalWrite(LED_PIN, HIGH); // dahili LED test sırasında yanar / onboard LED lights during the test
17 digitalWrite(pins[i], HIGH);
18 delay(1000);
19 digitalWrite(pins[i], LOW);
20 digitalWrite(LED_PIN, LOW);
21 delay(200);
22 }
23}Quais pinos são seguros? As mesmas regras nas duas placas
| Pin | Situação | Por quê? |
|---|---|---|
| GPIO 6–11 | Não use | Ligados à flash; só expostos na placa de 38 pinos |
| GPIO 0 | Use com cuidado | Ligado ao botão BOOT; se estiver em LOW ao iniciar, a placa entra em modo de upload |
| GPIO 2 | Use com cuidado | Deve estar em LOW ou solto durante o upload; aciona o LED integrado na DevKit V1 |
| GPIO 12 | Use com cuidado | Se estiver em HIGH ao iniciar, é escolhido 1,8 V para a flash e a placa não inicia |
| GPIO 15 | Use com cuidado | Se estiver em LOW ao iniciar, as mensagens de boot ficam mudas |
| GPIO 1 e 3 | Use com cuidado | TX0 e RX0 da conexão serial USB |
| GPIO 34, 35, 36, 39 | Só entrada | Não podem ser saídas e não têm pull-up interno |
| GPIO 16 e 17 | Não use no WROVER | Ligados à PSRAM no WROVER; disponíveis no WROOM (TX2 e RX2) |
| GPIO 4, 5, 13, 14, 18, 19, 21–23, 25–27, 32, 33 | Seguros | Entrada e saída de uso geral |
Pinos de alimentação: VIN, 5V e 3V3
O pino VIN da placa de 30 pinos e o pino 5V da placa de 38 pinos fazem o mesmo trabalho: estão ligados à linha de 5 V do USB e alimentam o regulador de 3,3 V da placa (normalmente um AMS1117). Para usar a placa sem USB, você fornece 5 V por esse pino; o regulador precisa de pelo menos uns 4,5 V e esquenta muito com tensões maiores, então 5–6 V é a faixa mais segura. O pino 3V3 é a saída do regulador, e você pode alimentar os seus sensores por ele. Como o ESP32 puxa picos de até 250 mA quando o Wi-Fi liga, não tire mais que algumas centenas de mA do 3V3. Alimentar o VIN com o cabo USB ligado também pode unir duas fontes; escolha uma.
Se você usa MicroPython
As placas de 30 e de 38 pinos rodam o mesmo firmware MicroPython: basta gravar a versão genérica de ESP32 da Espressif, ou a versão com PSRAM (SPIRAM) para placas WROVER. No shell do Thonny, estas poucas linhas mostram o tamanho da flash e a velocidade da CPU e acendem o LED da DevKit V1:
1import esp, machine
2
3print("Flas / Flash:", esp.flash_size() // (1024 * 1024), "MB")
4print("CPU:", machine.freq() // 1000000, "MHz")
5
6led = machine.Pin(2, machine.Pin.OUT) # DevKit V1 dahili LED / onboard LED
7led.on()Qual comprar? Um guia rápido de decisão
- Para praticar em protoboard ou ensinar: pegue uma DevKit V1 de 30 pinos, de preferência uma estreita com 22,86 mm entre as fileiras de pinos; o LED integrado também ajuda nos primeiros testes.
- Se o esquema ou o livro que você segue usa uma placa específica: compre a mesma placa; como as posições dos pinos são diferentes, você não vai precisar traduzi-las.
- Se você precisa do GPIO 0 ou a sua placa de expansão é de 38 pinos: escolha a placa de 38 pinos.
- Para projetos com câmera, display grande ou áudio: considere uma placa com módulo WROVER, ou vá direto para um ESP32-CAM.
- Se você não quer dor de cabeça com drivers: escolha uma placa mais nova com CP2102 ou CH340C e porta USB-C.
- Placas ESP32-S3, C3 ou C6: são chips diferentes; os números e a disposição dos pinos não são compatíveis com as placas deste artigo.
Erros comuns e como resolvê-los
- Erro "LED_BUILTIN was not declared": essa constante não é definida quando o ESP32 Dev Module está selecionado. Escreva 2 no lugar de LED_BUILTIN ou escolha DOIT ESP32 DEVKIT V1 como placa.
- Liguei no pino do esquema e não funciona: o esquema pode ter sido desenhado para a outra disposição. Ligue pela marcação impressa e pelo número do GPIO, e não pela posição.
- A placa não inicia ou fica reiniciando: pode haver algo ligado aos GPIO 6–11, ou o GPIO 12 está em HIGH ao iniciar. Tire o que estiver nesses pinos e tente de novo.
- A porta não aparece: o cabo pode ser só de carga, ou falta o driver do chip USB. Use um cabo de dados e compare o nome no Gerenciador de Dispositivos com a tabela.
- Erro "Failed to connect": segure o BOOT quando o upload começar; se continuar acontecendo, baixe o Upload Speed para 115200. Mais soluções em ESP32 Failed to Connect.
- A PSRAM mostra 0 em uma placa WROVER: a opção PSRAM ficou em Disabled no menu Ferramentas; coloque em Enabled e carregue de novo.
Resumindo, as placas ESP32 de 30 e de 38 pinos têm o mesmo cérebro; o que as diferencia é onde ficam os pinos, o GPIO 0 e como a placa se encaixa na sua bancada. Depois de ler as marcações da sua placa e confirmá-las com o sketch de teste, você acha os pinos certos qualquer que seja o esquema que seguir. Para os primeiros experimentos, confira no app BlueGrays os projetos ESP32 de LED integrado, LED externo, LEDs controlados por botão, semáforo, medição de luz com LDR, LCD I2C e conexão Wi-Fi; cada um guia você pelo esquema de ligação e pelo código passo a passo.
Perguntas frequentes
Compro o ESP32 de 30 ou de 38 pinos?
Se você vai trabalhar em protoboard e não tem uma necessidade especial, a DevKit V1 de 30 pinos costuma ser mais prática e a maioria tem LED integrado. Escolha a placa de 38 pinos se quiser usar o GPIO 0, tiver uma placa de expansão de 38 pinos ou se o esquema que você segue foi desenhado para ela. O processador e o código são os mesmos nas duas.
Preciso mudar o meu código para um ESP32 de 30 pinos?
Não. Desde que o código use números de GPIO, ele roda igual nas placas de 30 e de 38 pinos. Só confira se um código escrito para a placa de 38 pinos não usa o GPIO 0 ou os pinos da flash, porque esses pinos não estão expostos na placa de 30 pinos.
Em qual pino fica o LED integrado do ESP32 DevKit V1?
Nas placas DevKit V1 o LED azul do usuário fica no GPIO 2. Com o ESP32 Dev Module selecionado na Arduino IDE, o LED_BUILTIN não é definido, então escreva 2 direto no código ou escolha a placa DOIT ESP32 DEVKIT V1. O LED vermelho é só indicador de energia e não pode ser controlado.
Qual placa escolho na Arduino IDE para um ESP32 de 38 pinos?
Para todas as placas com módulo WROOM, sejam de 30 ou de 38 pinos, o ESP32 Dev Module é tudo de que você precisa. Se a sua placa de 38 pinos tiver módulo WROVER, escolha ESP32 Wrover Module ou ative a opção PSRAM no ESP32 Dev Module.
Qual é a diferença entre ESP32 WROOM e WROVER?
Os dois contêm o mesmo chip ESP32. O WROVER acrescenta de 2 a 8 MB de PSRAM e é um pouco mais comprido, mas em troca os GPIO 16 e 17 ficam reservados a essa memória. A não ser que você trabalhe com câmera, display grande ou áudio, um WROOM basta.
Como saber se o meu ESP32 tem CP2102 ou CH340?
Olhe o pequeno chip ao lado da porta USB: um quadrado sem perninhas costuma ser um CP2102, enquanto um retangular com perninhas dos dois lados é um CH340. No Gerenciador de Dispositivos do Windows a placa aparece como "Silicon Labs CP210x" ou "USB-SERIAL CH340"; no ID de hardware, 10C4 significa Silicon Labs e 1A86 significa WCH.
Projetos para montar depois desta leitura
Ver todos os projetos
LED integrado do ESP32 piscando
Faça o LED azul integrado do ESP32 DevKit V1 piscar. Nenhum componente externo é necessário! O primeiro projeto para experimentar ao comprar um ESP32. GPIO 2 está conectado ao LED integrado.

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Controle de LED com botão no ESP32 (momentâneo)
O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. Mostra como usar o pino de entrada digital e o resistor pull-up interno do ESP32. O modo INPUT_PULLUP dispensa um resistor externo.

Controle de LED com botão no ESP32 (alternância)
Cada vez que o botão é pressionado, o estado do LED muda: se estiver aceso, apaga; se estiver apagado, acende. É o padrão clássico de alternância. Com debounce, eliminamos o ruído mecânico dos contatos do botão para garantir uma única mudança a cada pressionamento.

Semáforo com ESP32
Simulação de um semáforo real com 3 LEDs: vermelho, amarelo e verde. Os tempos se aproximam da lógica real: vermelho longo, amarelo curto e verde longo. Um exemplo clássico de controle sequencial de GPIOs.

Leitura da intensidade da luz com módulo LDR e ESP32
Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

Display LCD I2C com ESP32 (16x2)
Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

