ESP32-CAM development board with CH340G, WiFi, Bluetooth, OV5640 5MP

The ESP32-CAM board with the 5 MP OV5640 camera is a complete ESP32 development board, with a microcontroller, camera, microSD card slot and antenna all on the same board. It is designed for video streaming projects, surveillance, event-triggered photography and other IoT applications that need an image sent over WiFi to a phone, a computer or a local server.

Since this is an ESP32 board, the tutorial uses the ESP32-CAM board directly, programmed in Arduino IDE as "AI Thinker ESP32-CAM", together with the CH340G programmer module included in the kit. No other development board is needed.

How it works:

The OV5640 camera sends the image to the ESP32 over an 8-bit parallel bus (pins D0-D7), accompanied by the PCLK, VSYNC and HREF synchronization signals and by the I2C-compatible SCCB bus (SIOD/SIOC), through which the microcontroller configures the sensor's resolution, exposure and white balance. The ESP32 stores the frames in the external 4 MB PSRAM, compresses them to JPEG using the integrated hardware encoder and makes them available through an HTTP server running over WiFi, at the IP address received from the router.

The resolution chosen in the code, for example SVGA (800x600) or VGA (640x480), determines the size of each JPEG frame, and therefore the transmission speed over WiFi. That is why a lower resolution is used for a continuous video stream, while the maximum resolution of the OV5640 sensor, 2592x1944 (5 MP), is used only for individual photos.

Wiring:

The ESP32-CAM board is powered separately at 5 V, and programming is done through the CH340G programmer module, which connects the board's serial pins to the computer's USB port.

All the electronics on the board work at 3.3 V, and the CH340G programmer module uses the same logic level on its serial pins, so no level shifter is needed between the two boards. The VCC pin on the ESP32-CAM board is a 3.3 V or 5 V output and must not be used to power the board. A 5 V power supply of at least 2 A is mandatory for stable operation of the OV5640 camera. A computer USB port is often not enough for normal operation, although it can be used temporarily just for programming.

Board and libraries:

Select the "AI Thinker ESP32-CAM" board from the Tools > Board menu, after installing the "esp32 by Espressif Systems" package from Tools > Board > Boards Manager. If the package does not appear in the list, add the address https://dl.espressif.com/dl/package_esp32_index.json in File > Preferences, under Additional Boards Manager URLs.

You do not need to install any additional library from Library Manager. The esp_camera.h, WiFi.h and WebServer.h libraries are part of the esp32 package installed above.

The code:

The code initializes the camera with the AI Thinker model's pin mapping, connects to the WiFi network and starts a simple HTTP server with a main page and an address from which a photo can be downloaded in JPEG format.

/*
  ESP32-CAM OV5640 5MP - simple snapshot web server
  Board: AI Thinker ESP32-CAM (install package "esp32 by Espressif Systems" from Boards Manager,
  Additional Boards Manager URL: https://dl.espressif.com/dl/package_esp32_index.json)
  Libraries: none to install separately, esp_camera.h, WiFi.h and WebServer.h are part of the esp32 board package
  Wiring: camera and microSD pins are fixed on board, programming uses U0R, U0T, IO0 and GND
  through the included ESP32-CAM-MB CH340G programmer, power is supplied on the 5V/GND pins
*/
#include "esp_camera.h"
#include <WiFi.h>
#include <WebServer.h>
// Camera pin map for the AI Thinker ESP32-CAM board
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22
#define FLASH_LED_GPIO_NUM 4
// WiFi credentials, replace with your own network
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
WebServer server(80);
// Serve a simple HTML page with a link to the snapshot
void handleRoot() {
  String html = "<html><body><h1>ESP32-CAM OV5640</h1>";
  html += "<p><a href=\"/capture\">Get snapshot</a></p></body></html>";
  server.send(200, "text/html", html);
}
// Capture one JPEG frame and send it to the browser
void handleCapture() {
  camera_fb_t *fb = esp_camera_fb_get();
  if (!fb) {
    Serial.println("Camera capture failed");
    server.send(503, "text/plain", "Camera capture failed");
    return;
  }
  server.sendHeader("Content-Disposition", "inline; filename=capture.jpg");
  server.send_P(200, "image/jpeg", (const char *)fb->buf, fb->len);
  esp_camera_fb_return(fb);
  Serial.printf("Snapshot sent, size %u bytes\n", fb->len);
}
void setup() {
  Serial.begin(115200);
  Serial.println();
  // Flash LED pin kept off at startup
  pinMode(FLASH_LED_GPIO_NUM, OUTPUT);
  digitalWrite(FLASH_LED_GPIO_NUM, LOW);
  // Camera configuration structure
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  // Use a larger frame and double buffering when PSRAM is available
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 15;
    config.fb_count = 1;
  }
  // Initialize the camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return;
  }
  Serial.println("Camera initialized");
  // Connect to WiFi
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi connected, IP address: ");
  Serial.println(WiFi.localIP());
  // Register HTTP routes and start the server
  server.on("/", handleRoot);
  server.on("/capture", handleCapture);
  server.begin();
  Serial.println("HTTP server started");
  Serial.println("Open the IP address above in a browser, then click Get snapshot");
}
void loop() {
  server.handleClient();
}

How the code works:

At the beginning of the file the camera pin constants are defined, PWDN_GPIO_NUM, RESET_GPIO_NUM, XCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM, Y2_GPIO_NUM-Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM and PCLK_GPIO_NUM, with the fixed values used on the AI Thinker board, plus FLASH_LED_GPIO_NUM for the LED on GPIO4. The ssid and password variables must be filled in with your WiFi network details, and the server object, of type WebServer, is created on port 80.

In the setup function, after starting serial communication, the camera_config_t structure is filled in with the camera pins, the PIXFORMAT_JPEG image format and, depending on the result of psramFound, the FRAMESIZE_SVGA resolution with two frame buffers when the board has PSRAM, or FRAMESIZE_VGA with a single buffer otherwise. The esp_camera_init function starts the camera, and in case of an error the message is displayed on Serial. Next comes the WiFi connection with WiFi.begin, a loop that waits until WiFi.status returns WL_CONNECTED, and the registration of the two routes, handleRoot for the main page and handleCapture for the photo, before server.begin is called.

The handleCapture function requests a new frame with esp_camera_fb_get, sends it to the browser with server.send_P using the image/jpeg type, then releases the frame memory with esp_camera_fb_return. In the loop function, server.handleClient is called continuously to respond to requests received over HTTP.

Result:

On the Serial Monitor, at 115200 baud, you can see the connection to the WiFi network and the IP address received by the board, followed by the confirmation that the HTTP server has started. If you open the displayed IP address followed by /capture in a browser, a photo taken at that moment by the OV5640 camera is downloaded.

Camera initialized
Connecting to WiFi.......
WiFi connected, IP address: 192.168.0.115
HTTP server started
Open the IP address above in a browser, then click Get snapshot
Snapshot sent, size 48213 bytes
Snapshot sent, size 51042 bytes

Common problems:

Nothing appears on the Serial Monitor: check that the speed selected in the Serial Monitor is 115200 baud and that the programmer module is connected correctly, with U0R and U0T not swapped.

The code upload fails with a connection or synchronization message: hold down the Download button or connect GPIO0 to GND before starting the upload, and check that Flash Mode DIO is selected in Tools > Flash Mode.

The camera does not start and an initialization error appears on Serial: check the 5 V power supply, at least 2 A, because a weak supply causes resets (brownout) when the camera is initialized.

The image is white, dark or has stripes: let the camera adjust its exposure and white balance automatically for a few seconds, and check that the camera's FPC ribbon is seated correctly in the connector.

The board resets by itself during streaming: reduce the resolution and the JPEG quality in the code and check the power supply again, since a peak current of over 300 mA with a weak supply causes repeated resets.

The camera becomes very hot to the touch: this is normal behavior for the OV5640 sensor, but be sure to fit a heatsink on the back and avoid continuous streaming for long periods.

Limitations and tips:

The maximum 5 MP resolution of the OV5640 sensor is useful for photos, not for continuous streaming, where the WiFi transmission speed and the PSRAM memory practically limit the resolution to SVGA or HD. The module is not recommended for uninterrupted 24/7 operation, and for projects with periodic captures it is a good idea to turn the camera off between photos, using GPIO32, to reduce heating and power consumption. Starting from this code, the board can be extended with saving to the microSD card, motion detection with an external PIR sensor on one of the free pins, or integration into a larger surveillance system with several ESP32-CAM cameras.