Back to all projects
ESP32-S3 camera board on a breadboard connected to a laptop showing live object detection

Intermediate

Build a Camera / CV Starter

SensorsDisplaysIoT

See what your code sees — capture, stream, or process real images with an onboard camera, no separate SBC required.

4 real parts included

Total for this kit: 1,585.00 ฿

Doesn't include any order discount you may get at checkout.

What you'll need

Project Goal

Build a small camera vision system on a single board: capture still images and stream live video over Wi-Fi, using the onboard camera on the ESP32-S3 Camera Board Kit. By the end you will have a working web server running directly on the board that any browser on your network can open to view a live feed or trigger a photo capture, no separate single-board computer or cloud account required.

What the Controller Does

The ESP32-S3 is the brain of this build. It is used here specifically rather than the smaller ESP32-C3 boards elsewhere in this catalog because camera work needs meaningfully more RAM and processing headroom: decoding a live image sensor feed, holding frame buffers in memory, compressing frames to JPEG, and serving them over Wi-Fi all at once is real work for a microcontroller. The ESP32-S3's dual-core design lets it split this load, running the Wi-Fi and web server on one core while the camera pipeline runs on the other, which keeps the stream responsive instead of stalling.

What the Camera Does

The onboard camera module captures raw image frames from its sensor and hands them to the controller over a dedicated camera interface. The controller then either streams those frames live, typically encoded as MJPEG over a simple web server the ESP32-S3 itself hosts and viewable from any browser on the same network, or saves individual still frames to onboard storage when triggered. Nothing leaves your local network unless you explicitly build that in; the basic capture and streaming loop is entirely self-contained on the board.

Memory and Streaming Concepts

Camera frame buffers are memory-hungry. Even a modest resolution image takes real space to hold in RAM before it can be compressed and sent out, and a board without enough spare memory will fail to initialize the camera at higher resolutions, or will only support small, blocky images. This is what onboard PSRAM (extra external RAM built into the module) is for: it gives the camera pipeline room to hold full frame buffers without starving the rest of the program. If your build later needs to record video to storage rather than just stream single frames, expect memory and write-speed limits to bite even sooner. Start at a conservative resolution and only increase it once basic capture is working reliably.

Software and Library Concepts

Camera firmware for ESP32-family boards is typically built around a camera driver library that talks to the sensor over its control interface, plus example sketches for common patterns like a web-based camera server or a simple still-capture-to-storage routine. Be aware that camera libraries and tutorials are often written for a specific sensor family, and the configuration, and sometimes even the image quality and orientation, can differ between sensor families. Before following any specific online tutorial, confirm which sensor it assumes and check that it matches (or explicitly supports) the sensor on this board, rather than assuming every ESP32 camera tutorial will drop in without changes.

Testing and Troubleshooting

  • Camera fails to initialize: this is almost always a memory or PSRAM configuration issue in the code, not a hardware fault. Check that the board's PSRAM is actually being detected and correctly configured in your sketch before assuming the camera module itself is defective.
  • Image looks corrupted or has visible noise or garbled lines: check that the physical camera ribbon cable connector is fully and evenly seated in its socket. A partially seated flex-cable connector is one of the most common causes of this exact symptom on these camera modules.
  • Streaming works but is slow or laggy: this is normal behavior at high resolution over Wi-Fi, not necessarily a fault. Try dropping to a lower resolution or JPEG quality setting first and confirm the stream smooths out before suspecting a hardware or network problem.
  • No image at all but the board otherwise boots normally: double check the camera pin configuration in your code matches this board's actual wiring, since a mismatched pin map will leave the camera silently uninitialized even though the rest of the sketch runs fine.

Optional Future Upgrade: On-Device Object Detection

Basic capture and streaming is only the first stage of what a camera-equipped board can do. Running actual on-device object detection or image classification, having the board itself recognize what is in the frame rather than just showing it to you, is a real and separate step beyond this kit's out-of-the-box capability. It requires a trained model sized to fit the board's memory and processing budget, plus enough onboard resources left over after the camera pipeline to run inference on each frame. Treat this as a genuine future upgrade path to explore once you are comfortable with basic capture and streaming, not something this base kit does by default.

Wiring

  • Freenove ESP32-S3 Camera Board → computer via USB-C cable — power and programming/serial monitor
  • Camera module ships pre-attached to the board via a ribbon/board connector — do not disconnect or rewire it; there is nothing else to wire externally for this project

The exact camera data pin mapping is board-specific and not something to guess — Freenove's own example sketch (or the Arduino IDE's built-in ESP32 → Camera → CameraWebServer example) already ships with a correct `camera_pins.h` for known board models, so use that instead of hand-wiring pin numbers. Run the bring-up sketch below first to confirm the board and PSRAM are detected before moving to the camera example — PSRAM must show as available or the camera example will fail to allocate frame buffers.

Starter Code

// Bring-up sanity check ONLY - confirms the board is alive and PSRAM is detected
// before moving on to the camera example. This does NOT touch the camera at all,
// so it has no board-specific pin numbers to get wrong.

void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.println("=== ESP32-S3 Camera Board Bring-Up ===");
  Serial.print("Chip model: ");
  Serial.println(ESP.getChipModel());
  Serial.print("Chip revision: ");
  Serial.println(ESP.getChipRevision());
  Serial.print("CPU frequency (MHz): ");
  Serial.println(getCpuFrequencyMhz());
  Serial.print("PSRAM size (bytes): ");
  Serial.println(ESP.getPsramSize());
  Serial.print("Free heap (bytes): ");
  Serial.println(ESP.getFreeHeap());

  if (ESP.getPsramSize() == 0) {
    Serial.println("WARNING: No PSRAM detected - the camera example needs PSRAM enabled.");
    Serial.println("Check Tools > PSRAM is set to 'OPI PSRAM' (or your board's PSRAM option) in Arduino IDE.");
  }
}

void loop() {
  // Nothing to do here - this sketch is just a bring-up check.
}

/*
 * NEXT STEP - loading the real camera example (do this instead of guessing pins):
 * 1. In Arduino IDE: File > Examples > ESP32 > Camera > CameraWebServer
 *    (this ships with the Arduino-ESP32 core and already contains correct
 *    camera_pins.h definitions for known board models).
 * 2. In the sketch, find the block of "#define CAMERA_MODEL_..." lines near the
 *    top and uncomment the one matching your Freenove board (check Freenove's
 *    own product page/wiki for the exact model name - if none match exactly,
 *    use Freenove's own official example sketch instead, which ships with the
 *    correct camera_pins.h for their board).
 * 3. Enter your WiFi credentials, set PSRAM enabled in Tools, and upload.
 * 4. Open Serial Monitor at 115200 baud to get the board's IP address, then
 *    visit it in a browser to confirm the camera stream works.
 */

Not sure about a step? Ask us

Try this next

Small plastic project enclosure with AHT20 sensor and ESP32-C3 breadboard, on a windowsill Build a Room Temperature & Humidity Monitor WS2812B LED strip glowing warm on a desk edge, wired to PIR sensor and ESP32-C3 on a breadboard Build a Motion-Activated Desk Light Small enclosure and breadboard with ESP32-C3, AHT20, SD card module and DS3231 RTC, laptop showing logged data graph Build a Wireless Environmental Data Logger