Tutorial do ESP32-CAM: configuração, programação, transmissão ao vivo e cartão SD

O ESP32-CAM é uma placa de câmera Wi-Fi acessível que, mesmo medindo só 27 × 40 mm, traz um processador ESP32, uma câmera OV2640 de 2 megapixels, um slot para cartão microSD e um LED de flash branco. Sozinha, ela entra na rede da sua casa, transmite vídeo ao vivo para um navegador, tira fotos e as salva em um cartão SD ou envia pela internet. É a placa preferida para câmeras de segurança, câmeras de campainha, time-lapses do crescimento de plantas e carrinhos robô com vídeo, mas, como não tem conector USB, começar com ela é um pouco diferente das placas ESP32 com que você talvez esteja acostumado.

Neste guia você vai aprender a pinagem do ESP32-CAM AI-Thinker, como programá-lo com o adaptador ESP32-CAM-MB ou com um adaptador USB-TTL (incluindo a ligação IO0-GND), como obter uma imagem ao vivo no navegador com o exemplo pronto CameraWebServer e quais ajustes de PSRAM e de partição usar. Depois você vai ver as causas dos erros mais comuns, Camera init failed with error 0x105 e brownout, controlar o LED de flash e montar um sketch que salva uma foto em um cartão microSD quando você aperta um botão.

O que é o ESP32-CAM e como ele funciona?

O coração da placa é o módulo ESP32-S, que traz o chip ESP32 dual-core com Wi-Fi e Bluetooth. A câmera se encaixa em um conector de 24 pinos na placa por um cabo flat fino (FPC). O ESP32 envia à câmera um sinal de clock de 20 MHz (XCLK) pelo GPIO 0 e a configura pelo barramento SCCB, parecido com o I2C, nos GPIO 26 e 27. Como o sensor OV2640 consegue comprimir a imagem em JPEG sozinho, o ESP32 recebe pequenos quadros JPEG em vez de pixels brutos. Esses quadros passam por um barramento de dados paralelo de 8 bits até os 4 MB de PSRAM da placa, e o Wi-Fi os leva adiante até um navegador ou um servidor.

Pinagem do ESP32-CAM AI-Thinker: quais pinos estão livres?

Há 16 pinos nas duas bordas da placa, mas só alguns estão realmente livres: a câmera sozinha usa 15 GPIOs, e o slot microSD compartilha mais seis. A tabela abaixo resume os pinos das bordas e quando você pode usá-los. Você também pode explorar as características gerais dos pinos do ESP32 na ferramenta de pinagem.

Como programar o ESP32-CAM? Dois jeitos

O chip USB-serial que permite às placas ESP32 comuns conversar com o computador não existe no ESP32-CAM. Para carregar código você tem duas opções: o adaptador ESP32-CAM-MB, que encaixa por baixo da placa (uma pequena placa-base com um chip CH340 e um conector micro USB), ou um adaptador USB-TTL que você já tenha (FTDI, CH340, CP2102). Seja qual for a escolha, a lógica é a mesma: se o GPIO 0 estiver em LOW na inicialização, o ESP32 entra no modo de download e espera o código; se estiver em HIGH, ele roda o programa da flash. O botão IO0 do adaptador MB e o fio IO0-GND que você coloca com um adaptador USB-TTL fazem exatamente isso.

Se o seu adaptador tem um jumper de seleção 3,3 V / 5 V, coloque em 3,3 V para que a linha TX fique em um nível adequado aos pinos do ESP32. Mas alimente a placa pelo pino 5V do adaptador. A saída de 3,3 V da maioria dos adaptadores só fornece uns 50–100 mA; no momento em que o ESP32-CAM liga o Wi-Fi, essa alimentação despenca e a placa reinicia.

Ajustes da Arduino IDE: placa, esquema de partição e PSRAM

1. Abra o Gerenciador de Placas na Arduino IDE e instale o pacote esp32 by Espressif Systems; o guia de instalação da Arduino IDE explica em detalhes.
2. Selecione a placa AI Thinker ESP32-CAM em Ferramentas > Placa > esp32.
3. Confira se o Partition Scheme está em Huge APP (3MB No OTA/1MB SPIFFS); o exemplo da câmera precisa de pelo menos 3 MB de espaço para o app.
4. Ligue a placa ao adaptador e escolha a nova porta em Ferramentas > Porta (COMx no Windows, /dev/cu.usbserial... ou /dev/cu.wchusbserial... no macOS).
5. Se nenhuma porta aparecer, instale o driver CH340 ou CP2102 e use um cabo USB que transmita dados.

O seu primeiro carregamento, passo a passo

1. Faça a ligação: encaixe a placa no adaptador MB com os pinos alinhados ou ligue o adaptador USB-TTL como na tabela acima. Se estiver usando um adaptador USB-TTL, coloque também o fio curto entre IO0 e GND.
2. Coloque a placa no modo de download: no adaptador MB, segure o botão IO0, aperte e solte o RST e depois solte o IO0. Com um adaptador USB-TTL, basta apertar RST com o fio IO0-GND no lugar. Alguns adaptadores MB com circuito de reset automático carregam sem apertar nenhum botão.
3. Clique em Carregar na Arduino IDE. A saída mostra primeiro Connecting... e depois o progresso da gravação em porcentagem.
4. Quando aparecer a linha Hard resetting via RTS pin..., o carregamento terminou. Se estiver usando um adaptador USB-TTL, tire agora o fio IO0-GND.
5. Abra o Monitor Serial em 115200 baud e aperte RST; o programa novo começa a rodar.

1// ESP32-CAM ilk yükleme testi / ESP32-CAM first upload test
2const int KIRMIZI_LED = 33;   // arkadaki kırmızı LED, ters mantık / red LED on the back, inverted logic
3
4void setup() {
5  Serial.begin(115200);
6  pinMode(KIRMIZI_LED, OUTPUT);
7  delay(500);
8
9  // PSRAM kontrolü / PSRAM check
10  if (psramFound()) {
11    Serial.print("PSRAM bulundu / PSRAM found: ");
12    Serial.print(ESP.getPsramSize());
13    Serial.println(" bayt / bytes");
14  } else {
15    Serial.println("PSRAM yok / No PSRAM");
16  }
17}
18
19void loop() {
20  digitalWrite(KIRMIZI_LED, LOW);    // LOW = yanar / LOW = on
21  delay(500);
22  digitalWrite(KIRMIZI_LED, HIGH);   // HIGH = söner / HIGH = off
23  delay(500);
24}

Se o carregamento deu certo, o pequeno LED vermelho no verso da placa pisca a cada meio segundo. Esse LED usa lógica invertida: escrever LOW acende e HIGH apaga. No Monitor Serial você deve ver cerca de 4 milhões de bytes de PSRAM; se aparecer No PSRAM, confira a placa selecionada e, se não resolver, talvez a sua placa não tenha chip de PSRAM. Rodar este teste curto antes do exemplo da câmera mostra na hora se um problema está no carregamento ou na câmera.

O exemplo CameraWebServer: imagem ao vivo no navegador

1. Abra Arquivo > Exemplos > ESP32 > Camera > CameraWebServer.
2. Escolha o modelo da câmera: na lista da aba board_config.h (versões mais novas) ou no topo do arquivo principal (versões antigas), coloque // na frente da linha CAMERA_MODEL_ESP_EYE e tire o // da frente da linha CAMERA_MODEL_AI_THINKER.
3. Coloque o nome e a senha da sua rede Wi-Fi de 2,4 GHz nas linhas ssid e password.
4. Coloque a placa no modo de download e carregue o sketch; depois tire a ligação do IO0 e aperte RST.
5. No Monitor Serial você vai ver uma linha como Camera Ready! Use 'http://192.168.1.45' to connect; abra esse endereço no navegador de um celular ou computador na mesma rede.
6. Inicie a imagem ao vivo com o botão Start Stream da página ou tire uma única foto com Get Still.

1// board_config.h (eski sürümlerde CameraWebServer.ino) / (CameraWebServer.ino in older versions)
2//#define CAMERA_MODEL_ESP_EYE      // Has PSRAM  <- kapat / comment out
3#define CAMERA_MODEL_AI_THINKER     // Has PSRAM  <- aç / enable
4
5// CameraWebServer.ino
6const char *ssid = "AgAdi";          // Wi-Fi adı / Wi-Fi name
7const char *password = "Sifre123";   // Wi-Fi şifresi / Wi-Fi password

A interface roda em dois servidores separados: a página de configurações e o endereço /capture, que devolve uma única foto, ficam na porta 80, enquanto a transmissão ao vivo fica em /stream na porta 81 (por exemplo, http://192.168.1.45:81/stream). Você pode colocar esse endereço de transmissão na sua própria página web ou em um software de automação residencial. No menu à esquerda dá para mudar a resolução, a qualidade do JPEG, o brilho, o contraste e o balanço de branco e, se a imagem estiver de cabeça para baixo, usar as chaves V-Flip e H-Mirror; as versões mais novas também têm um controle deslizante LED Intensity para o flash. A placa costuma atender só um espectador da transmissão ao vivo por vez, então uma transmissão aberta em uma segunda aba pode travar. Se a página nem abrir, confira se o celular e a placa estão na mesma rede; para problemas de conexão, veja ESP32 não conecta ao Wi-Fi.

Tabela de resolução e FPS do ESP32-CAM

No papel, o sensor OV2640 consegue entregar 15 quadros por segundo em 1600×1200, 30 em 800×600 e 60 no tamanho CIF. Na prática, a taxa de quadros é definida principalmente pela conexão Wi-Fi e pelo tamanho dos quadros JPEG: conforme a resolução e a qualidade sobem, cada quadro fica maior e atravessa a rede mais devagar. Os valores abaixo são faixas aproximadas vistas com o CameraWebServer em um bom sinal de Wi-Fi, com qualidade JPEG 10–12. Para medir a sua placa, coloque o Core Debug Level em Info; durante a transmissão, o Monitor Serial mostra uma linha como MJPG: ... (x fps) a cada quadro.

No seu próprio código, você muda a resolução, a qualidade e a orientação pelo objeto do sensor depois que a câmera inicia com sucesso. A qualidade do JPEG é um número de 0 a 63, e um número menor significa qualidade maior; descer abaixo de 10 deixa os quadros maiores e pode gerar imagens pela metade.

1// esp_camera_init() başarılı olduktan sonra / after esp_camera_init() succeeds
2sensor_t *s = esp_camera_sensor_get();
3s->set_framesize(s, FRAMESIZE_VGA);   // 640x480 çözünürlük / resolution
4s->set_quality(s, 12);                // 0-63: küçük = daha kaliteli, 10 altı önerilmez / lower = better, below 10 not advised
5s->set_vflip(s, 1);                   // görüntüyü dikey çevir / flip vertically
6s->set_hmirror(s, 1);                 // yatay ayna / mirror horizontally
7s->set_brightness(s, 1);              // parlaklık -2..2 / brightness -2..2

Por que o ajuste de PSRAM do ESP32-CAM importa tanto?

A memória interna do ESP32 é de 520 KB, e a pilha do Wi-Fi usa boa parte dela. Já um único quadro JPEG de 1600×1200 pode ocupar 100–250 KB, dependendo da cena e da qualidade. Por isso o driver da câmera coloca os buffers de quadro na PSRAM. O CameraWebServer verifica a PSRAM com a função psramFound(): se ela existe, inicia na resolução máxima com dois buffers de quadro; se não, limita a resolução a SVGA (800×600) e mantém um único buffer na memória interna.

Se você pede uma resolução alta sem a PSRAM ativada, o Monitor Serial mostra frame buffer malloc failed seguido de Camera init failed with error 0xffffffff. A solução é selecionar AI Thinker ESP32-CAM como placa (com ESP32 Dev Module, coloque Ferramentas > PSRAM: Enabled) ou baixar a resolução e reduzir o número de buffers de quadro para 1. Alguns clones baratos podem nem ter chip de PSRAM; a linha da PSRAM no primeiro sketch de teste revela isso na hora.

Camera init failed with error 0x105 e outros erros da câmera

A maioria dos erros da câmera se resume a uma de três causas: o modelo de câmera errado no código, um cabo flat mal encaixado no conector ou uma alimentação insuficiente. Ler o código de erro no Monitor Serial estreita a causa rapidinho:

Erro de brownout e a alimentação certa (5 V / 2 A)

Se o Monitor Serial mostra Brownout detector was triggered e a placa fica reiniciando, a tensão de alimentação do ESP32 caiu por um instante abaixo de um nível seguro. O ESP32-CAM puxa picos de corrente curtos, mas altos, no momento em que liga o transmissor Wi-Fi e a câmera começa a capturar. Uma porta USB fraca, jumpers finos e longos ou a saída de 3,3 V do adaptador não acompanham esses picos. Estas são as soluções definitivas:

• Use uma fonte que forneça 5 V e pelo menos 2 A e ligue-a no pino 5V da placa; o regulador da placa baixa para 3,3 V.
• Mantenha os fios de alimentação curtos e grossos; protoboards e jumpers longos aumentam a queda de tensão.
• Coloque um capacitor eletrolítico de 470–1000 µF entre os pinos 5V e GND da placa, o mais perto possível dela (terminal positivo no 5V).
• Se alimentar pelo computador, ligue direto em uma porta na parte de trás do PC, em vez de um hub USB.
• Para funcionar com bateria, use uma célula 18650 com um módulo elevador de 5 V; isso é bem mais estável que uma fileira de pilhas AA.

Na internet você vai encontrar muito a linha WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0), que desliga o detector de brownout no código. Ela acaba com os reinícios, mas não resolve o problema: a tensão continua caindo, e a placa pode passar a travar, gerar quadros corrompidos ou perder dados ao gravar na flash. Use só para um teste temporário; a lista completa das mensagens de reinício está no guia ESP32 brownout e Guru Meditation. Ao estimar a duração da bateria, considere que a placa puxa em média 180 mA transmitindo sem parar: uma 18650 de 2600 mAh com um conversor elevador de 85% de eficiência dá cerca de 1600 mAh do lado de 5 V, ou seja, umas 9 horas de transmissão. Você pode calcular os seus próprios números com a calculadora de duração da bateria; lembre que, mesmo em deep sleep, a placa puxa cerca de 6 mA por causa do regulador e da PSRAM.

Controlando o LED de flash (GPIO 4)

O LED branco forte na frente da placa é acionado por um transistor ligado ao GPIO 4, então o pino só chaveia o transistor, e a corrente alta do LED vem da linha de alimentação. digitalWrite(4, HIGH) acende e LOW apaga. O LED é muito forte e, se ficar aceso por muito tempo, tanto ele quanto a placa esquentam; o melhor é acender o flash só por algumas centenas de milissegundos ao tirar uma foto. O GPIO 4 também é a linha DATA1 do cartão microSD, então, quando o cartão funciona no modo de 4 bits, o flash pisca sozinho a cada leitura e gravação. Para evitar isso, inicie o cartão SD no modo de 1 bit (SD_MMC.begin("/sdcard", true)); em algumas placas o LED ainda pode brilhar bem de leve.

Salvando fotos em um cartão microSD com o ESP32-CAM

O sketch abaixo acende o flash, tira uma foto em 1600×1200 e a salva no cartão microSD como foto1.jpg, foto2.jpg... toda vez que você aperta um botão no GPIO 13. Formate o cartão microSD em FAT32 no computador; embora a documentação oficial fale em cartões de até 4 GB, cartões FAT32 de 16–32 GB costumam funcionar bem na prática. Ligue uma perna do botão no GPIO 13 e a outra no GND; o sketch ativa o resistor de pull-up interno, então não precisa de resistor extra. Para entender como funciona a ligação de botões, veja Como ligar um botão no Arduino.

1#include "esp_camera.h"
2#include "FS.h"
3#include "SD_MMC.h"
4
5// AI-Thinker ESP32-CAM kamera pinleri / AI-Thinker ESP32-CAM camera pins
6#define PWDN_GPIO_NUM     32
7#define RESET_GPIO_NUM    -1
8#define XCLK_GPIO_NUM      0
9#define SIOD_GPIO_NUM     26
10#define SIOC_GPIO_NUM     27
11#define Y9_GPIO_NUM       35
12#define Y8_GPIO_NUM       34
13#define Y7_GPIO_NUM       39
14#define Y6_GPIO_NUM       36
15#define Y5_GPIO_NUM       21
16#define Y4_GPIO_NUM       19
17#define Y3_GPIO_NUM       18
18#define Y2_GPIO_NUM        5
19#define VSYNC_GPIO_NUM    25
20#define HREF_GPIO_NUM     23
21#define PCLK_GPIO_NUM     22
22
23#define FLAS_LED  4    // beyaz flaş LED'i / white flash LED
24#define BUTON    13    // butonun diğer ucu GND'de / other button leg to GND
25
26int fotoNo = 1;        // sıradaki dosya numarası / next file number
27bool hazir = false;    // kamera ve SD hazır mı? / are camera and SD ready?
28
29bool kameraBaslat() {
30  camera_config_t config = {};
31  config.ledc_channel = LEDC_CHANNEL_0;
32  config.ledc_timer   = LEDC_TIMER_0;
33  config.pin_d0 = Y2_GPIO_NUM;
34  config.pin_d1 = Y3_GPIO_NUM;
35  config.pin_d2 = Y4_GPIO_NUM;
36  config.pin_d3 = Y5_GPIO_NUM;
37  config.pin_d4 = Y6_GPIO_NUM;
38  config.pin_d5 = Y7_GPIO_NUM;
39  config.pin_d6 = Y8_GPIO_NUM;
40  config.pin_d7 = Y9_GPIO_NUM;
41  config.pin_xclk     = XCLK_GPIO_NUM;
42  config.pin_pclk     = PCLK_GPIO_NUM;
43  config.pin_vsync    = VSYNC_GPIO_NUM;
44  config.pin_href     = HREF_GPIO_NUM;
45  config.pin_sccb_sda = SIOD_GPIO_NUM;
46  config.pin_sccb_scl = SIOC_GPIO_NUM;
47  config.pin_pwdn     = PWDN_GPIO_NUM;
48  config.pin_reset    = RESET_GPIO_NUM;
49  config.xclk_freq_hz = 20000000;           // 20 MHz kamera saati / 20 MHz camera clock
50  config.pixel_format = PIXFORMAT_JPEG;
51
52  if (psramFound()) {
53    config.frame_size   = FRAMESIZE_UXGA;   // 1600x1200
54    config.jpeg_quality = 10;               // küçük = daha kaliteli / lower = better quality
55    config.fb_count     = 2;
56    config.fb_location  = CAMERA_FB_IN_PSRAM;
57    config.grab_mode    = CAMERA_GRAB_LATEST;
58  } else {
59    config.frame_size   = FRAMESIZE_SVGA;   // PSRAM yoksa 800x600 / 800x600 without PSRAM
60    config.jpeg_quality = 12;
61    config.fb_count     = 1;
62    config.fb_location  = CAMERA_FB_IN_DRAM;
63    config.grab_mode    = CAMERA_GRAB_WHEN_EMPTY;
64  }
65
66  esp_err_t err = esp_camera_init(&config);
67  if (err != ESP_OK) {
68    Serial.printf("Camera init failed 0x%x (%s)\n", err, esp_err_to_name(err));
69    return false;
70  }
71  return true;
72}
73
74void fotoCek() {
75  digitalWrite(FLAS_LED, HIGH);              // flaşı yak / flash on
76  delay(150);                                // pozlama otursun / let exposure settle
77
78  camera_fb_t *fb = esp_camera_fb_get();     // eski kareyi at / discard the stale frame
79  if (fb) esp_camera_fb_return(fb);
80  fb = esp_camera_fb_get();                  // asıl fotoğraf / the real photo
81  digitalWrite(FLAS_LED, LOW);               // flaşı söndür / flash off
82
83  if (!fb) {
84    Serial.println("Kare alinamadi / Capture failed");
85    return;
86  }
87
88  String yol = "/foto" + String(fotoNo) + ".jpg";
89  File dosya = SD_MMC.open(yol, FILE_WRITE);
90  if (dosya) {
91    dosya.write(fb->buf, fb->len);           // JPEG verisini yaz / write the JPEG data
92    dosya.close();
93    Serial.printf("Kaydedildi / Saved: %s (%u bayt / bytes)\n", yol.c_str(), (unsigned)fb->len);
94    fotoNo++;
95  } else {
96    Serial.println("Dosya acilamadi / Could not open file");
97  }
98  esp_camera_fb_return(fb);                  // tamponu geri ver / return the buffer
99}
100
101void setup() {
102  Serial.begin(115200);
103  pinMode(BUTON, INPUT_PULLUP);
104
105  if (!kameraBaslat()) return;               // kamera yoksa dur / stop without a camera
106
107  // 1-bit mod: GPIO 4, 12 ve 13 boşta kalır / 1-bit mode keeps GPIO 4, 12 and 13 free
108  if (!SD_MMC.begin("/sdcard", true)) {
109    Serial.println("SD kart takilamadi / SD card mount failed");
110    return;
111  }
112  if (SD_MMC.cardType() == CARD_NONE) {
113    Serial.println("SD kart yok / No SD card");
114    return;
115  }
116
117  pinMode(FLAS_LED, OUTPUT);
118  digitalWrite(FLAS_LED, LOW);
119
120  // Var olan fotoğrafların üzerine yazma / don't overwrite existing photos
121  while (SD_MMC.exists("/foto" + String(fotoNo) + ".jpg")) fotoNo++;
122
123  hazir = true;
124  Serial.println("Hazir, butona bas / Ready, press the button");
125}
126
127void loop() {
128  if (!hazir) {                              // hata varsa bekle / wait if setup failed
129    delay(1000);
130    return;
131  }
132  if (digitalRead(BUTON) == LOW) {
133    delay(30);                               // buton sıçramasını (bounce) önle / debounce
134    if (digitalRead(BUTON) == LOW) {
135      fotoCek();
136      while (digitalRead(BUTON) == LOW) delay(10);   // bırakılmasını bekle / wait for release
137    }
138  }
139}

Como o sketch inicia o cartão SD no modo de 1 bit, ele só usa os GPIO 2, 14 e 15, o que deixa o GPIO 4 para o flash e o GPIO 13 para o botão. Antes de tirar a foto, um quadro é capturado e devolvido na hora: a câmera produz quadros sem parar, então o primeiro quadro no buffer pode ter sido capturado antes de o flash acender, e a exposição automática precisa de uma pequena pausa para se ajustar à luz nova. O número do arquivo é definido olhando os arquivos que já estão no cartão, então as fotos antigas não são sobrescritas nem depois de um reinício. Para as regras gerais de registro de dados em um cartão SD, dê uma olhada no guia do módulo de cartão SD.

MicroPython e placas de câmera mais novas

Você também pode programar o ESP32-CAM com MicroPython, mas a versão oficial do MicroPython não inclui driver de câmera; é preciso gravar um firmware da comunidade com suporte à câmera. Por isso o caminho da Arduino IDE é bem mais tranquilo para iniciantes. Se você prefere não lidar com uma placa sem conector USB, considere também as placas de câmera baseadas no ESP32-S3, com USB e mais memória (por exemplo, a Seeed XIAO ESP32S3 Sense ou a ESP32-S3-EYE); essas placas também aparecem na lista de modelos do CameraWebServer.

Ideias de projetos com ESP32-CAM

• Foto ao detectar movimento: tire uma foto quando um sensor PIR perceber alguém e envie para o seu celular; o passo a passo está em fotos do ESP32-CAM no Telegram.
• Gravação em time-lapse: deixe a placa acordar a cada 10 minutos, tirar uma foto, salvar no cartão SD e voltar ao deep sleep; acompanhe uma planta crescendo ou o tempo mudando.
• Câmera de campainha: fotografe a frente da sua porta quando o botão da campainha for apertado e envie uma notificação com um bot do Telegram.
• Carrinho robô com vídeo: dirija o carrinho acompanhando uma transmissão ao vivo fluida em QVGA no celular.
• Câmera para pets: assista à transmissão ao vivo na rede da sua casa e ligue o flash pela página web quando precisar.
• Seu próprio painel de controle: coloque a transmissão ao vivo na sua própria página web e acrescente ao lado leituras de relés e sensores; o guia ESP32 WebSocket mostra o caminho.

Erros comuns e como corrigir

O ESP32-CAM é o jeito mais fácil de montar uma câmera Wi-Fi em uma placa acessível, e quase toda dificuldade que você vai encontrar vem da ligação de programação ou da alimentação. Acertando essas duas coisas, a placa transmite vídeo ao vivo pelo próprio servidor web, tira fotos e as salva em um cartão SD. No app BlueGrays você encontra projetos com ESP32 como conexão Wi-Fi, servidor web, mDNS, registro de dados em microSD e um alarme de movimento com notificações no Telegram, cada um com esquemas do circuito passo a passo e código pronto para usar.