Project Files of ESP32-CAM Library for Proteus: OV2640 Camera, microSD and PIR

ESP32-CAM LIBRARY FOR PROTEUS - V1.0 (YOUR ESP32-CAM SKETCH, THE OV2640 CAMERA, THE MICROSD CARD AND THE FLASH LED)
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/10/esp32-cam-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/esp32-cam-proteus-library
The demo's parts are our libraries (included) - their articles:
  HC-SR501 PIR sensor:
    https://www.theengineeringprojects.com/2026/10/pir-sensor-library-for-proteus-v4-0.html
  Relay module:
    https://www.theengineeringprojects.com/2026/10/relay-module-library-for-proteus-v1-0.html
  Laptop and phone:
    https://www.theengineeringprojects.com/2026/10/laptop-wifi-monitor-library-for-proteus.html
    https://www.theengineeringprojects.com/2026/10/mobile-wifi-monitor-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
ESP32-CAM-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPESP32CAM.LIB                                  27.9 KB   the ESP32-CAM, to LIBRARY
|   |-- TEPHCSR501.LIB                                  391.6 KB   the HC-SR501 PIR sensor (demo), to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPRELAY.LIB                                    490.4 KB   the relay module (demo), to LIBRARY
|-- Proteus Model Files/
|   |-- TEPHCSR501.DLL                                  400.0 KB   the HC-SR501 PIR sensor, to MODELS
|   |-- TEPNET.DLL                                       2.63 MB   the board + monitors + network, to MODELS
|   |-- TEPRELAY.DLL                                    330.0 KB   the relay module, to MODELS
|-- Arduino Code/
|   |-- ESP32CAM_PIR_Snapshot/ESP32CAM_PIR_Snapshot.ino    8.5 KB   the demo sketch
|   |-- TEP Boards for Proteus/hardware/                882.5 KB   the Arduino IDE add-on 1.37.0 (205 files)
|-- Proteus Simulation/
|   |-- ESP32CAM_PIR_Snapshot.hex                        70.5 KB   the demo sketch (U1)
|   |-- ESP32-CAM-PIR-Snapshot.pdsprj                    32.0 KB   the demo: a motion-triggered porch camera
|   |-- TEPHCSR501.DLL                                  400.0 KB   copy of the model
|   |-- TEPNET.DLL                                       2.63 MB   copy of the model
|   |-- TEPRELAY.DLL                                    330.0 KB   copy of the model
|-- README.txt                                          ~15.0 KB   this file
Total: 8.61 MB (unzipped). The source code of the models is not included.

WHAT IS IT?
Proteus 8 has no ESP32 or OV2640 model, so this is NOT a real ESP32 or a real camera. It is the AI-Thinker ESP32-CAM -
the 40.5 x 27 mm board with the ESP32-S module and its PCB antenna, the OV2640 camera, the microSD slot, the white flash
LED and 2 x 8 header pins - that runs YOUR ESP32-CAM Arduino sketch in Proteus and takes pictures:
  * You write a normal ESP32-CAM sketch (esp_camera.h: camera_config_t, esp_camera_init, esp_camera_fb_get, sensor_t;
    SD_MMC.h and FS.h; WiFi.h and WebServer.h; the GPIO numbers 0, 1, 2, 3, 4, 12 .. 16, 33) and compile it in the
    Arduino IDE with our board package "TEP Boards for Proteus" 1.37.0 (in Arduino Code - see INSTALLATION).
  * Inside the board, Proteus's own ATmega2560 model runs the compiled sketch at 16 MHz; our model (TEPNET.DLL) wraps
    it: the header pins, the flash LED on GPIO4, the red LED on GPIO33, Wi-Fi with our Laptop / Mobile WiFi Monitors,
    the built-in serial monitor on U0T / U0R - and the camera and the card.
  * The camera: esp_camera_fb_get() takes a picture - a real JPEG at the frame size and quality of the sketch (VGA 640 x
    480 at quality 12: about 20 KB). The model draws the scene of the board's CAMSCENE property: PORCH (a front door at
    night), DESK or TESTCARD. A visitor walks into the picture while the CAMMOTION GPIO is HIGH (13: the PIR on IO13
    sees the same person), and the flash LED on GPIO4 lights the porch. The sensor_t setters change the pictures:
    brightness, contrast, saturation, special effect, hmirror, vflip, colour bars, framesize and quality.
  * The JPEG stays in the board model (the hidden ATmega2560 has 8 KB of RAM): fb->buf is a token. client.write(fb->buf,
    fb->len), server.send_P(200, "image/jpeg", (const char *)fb->buf, fb->len) and file.write(fb->buf, fb->len) pass the
    picture on - to a browser or to the card - exactly as on the real board.
  * The microSD card: SD_MMC.begin, open, write, read, openNextFile, exists, remove, rename, mkdir;
    WebServer::streamFile sends a file. The card's files live in the board model (SDCARD: 4GB .. 32GB, or NO for an
    empty slot); SDFOLDER puts a copy of every file written on your PC - open the photos in any picture viewer.
  * Our Laptop and Mobile WiFi Monitors now show pictures: a page's <img> (and a link to a .jpg) appears in their
    browsers.
TEP additions: the flash LED glows in the simulation; a click on the ESP32-S module opens the Wi-Fi panel, a click on
the U0R / U0T pins the serial monitor (the real board has no USB: the monitor stands in for the FTDI adapter).
Limits (say them before you start): 16 MHz, 8 KB of RAM (the real ESP32: 240 MHz, 520 KB + 4 MB PSRAM), pictures up to
64 KB, the frame's bytes cannot be read in the sketch (fb->buf[i]), JPEG only. See MODEL SCOPE AND LIMITS.

ONE DEVICE (search "ESP32-CAM" in Pick Devices):
  AI-THINKER ESP32-CAM  "ESP32-CAM" V1.0 (Microprocessor ICs > ESP32 Boards), prefix U, model TEPNET.DLL. The serial
  monitor (115200 baud) has Monitor, Plotter and Board tabs (the Board tab: the flash LED, every pin). Like every TEP
  window it has no Windows title bar.
The same TEPNET.DLL also runs our other sketch boards and the Laptop / Mobile WiFi Monitors; it replaces any older
TEPNET.DLL (keep only this newest one in MODELS).

TEST STATUS
V1.0: verified in Proteus 8.5 on 27 Oct 2026 with the demo project as shipped. What the Proteus run showed:
* ESP32-CAM-PIR-Snapshot: the monitor printed "Camera: OV2640 (PID 0x26), VGA JPEG", "microSD card: 3796 MB",
  "Joining TEP-WiFi........." and "Camera page: http://192.168.1.101/"; the laptop (192.168.1.21) and the phone
  (192.168.1.41) opened the page (HTTP 200): "No photo yet", SNAP, LIVE, REFRESH, LIGHT.
* The motion button on the PIR's pop-up: "Motion 1", "Porch light ON", the flash LED lit, then "Photo 1: /photo1.jpg
  (36166 bytes, motion)" - a 640 x 480 JPEG of the porch with the visitor, lit by the flash; the relay's pop-up: K1
  ON (IN LOW).
* REFRESH on the laptop: the page with "Latest: /photo1.jpg" and the photo (the browser fetched /latest.jpg:
  streamFile from the card); the same page on the phone. SNAP on the phone: "Photo 2: /photo2.jpg (35831 bytes, SNAP
  on the page)". LIST in the monitor: photo1.jpg, photo2.jpg, "2 files, 70 KB used". LIVE on the laptop: /capture, a
  JPEG straight from the camera ("Live picture: 35831 bytes").
* About 19 s of simulation in about 3 minutes with the monitor, the PIR's and the relay's pop-ups and both tools
  open; no errors.

INSTALLATION (about 3 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" to the LIBRARY folder of Proteus, for example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\LIBRARY). TEPESP32CAM.LIB is the board; the
   others are the demo's parts: TEPHCSR501.LIB, TEPRELAY.LIB, TEPLAPTOP.LIB and TEPMOBILE.LIB.
3. Copy the DLLs from "Proteus Model Files" (TEPNET.DLL, TEPHCSR501.DLL, TEPRELAY.DLL) to the MODELS folder
   (...\Proteus 8 Professional\MODELS) - replace an older TEPNET.DLL (this one is the first that knows the ESP32-CAM and
   shows pictures in the laptop and the phone).
4. Delete TEPESP32CAM.IDX from the LIBRARY folder if it is there.
5. The Arduino IDE (only to compile your own sketches - the demo has its HEX file): copy the folder
   "Arduino Code\TEP Boards for Proteus\hardware" into your sketchbook folder (normally Documents\Arduino), so that
   Documents\Arduino\hardware\tep\avr\boards.txt exists (replace an older copy); restart the IDE. The Arduino AVR Boards
   platform must be installed (it comes with IDE 1.8.x; in IDE 2.x install "Arduino AVR Boards" from the Boards Manager
   once). Tools > Board > TEP Boards for Proteus > AI Thinker ESP32-CAM (TEP Proteus). esp32-camera, SD_MMC, WiFi and
   WebServer come with the package.
6. Start Proteus. In Pick Devices (P) search "ESP32-CAM".

RUN THE DEMO
Keep the .hex file and the DLLs beside the project in "Proteus Simulation".
ESP32-CAM-PIR-Snapshot.pdsprj - U1 the ESP32-CAM (ESP32CAM_PIR_Snapshot.hex) is a motion-triggered porch camera: U2 =
the HC-SR501 PIR (Advance; OUT on IO13 - also the camera's CAMMOTION GPIO) and RLY1 = the relay (Advance; IN on IO12:
the porch light - the module is active LOW: IN LOW = on). PC1 the Laptop WiFi Monitor and MOB1 the Mobile WiFi Monitor
open http://192.168.1.101/. Press Run. The monitor prints the camera ("Camera: OV2640 (PID 0x26), VGA JPEG"), the card
("microSD card: 3796 MB") and the page's address; the page says "No photo yet". On the PIR's pop-up click the motion
button: a visitor walks to the door, the flash LED lights, 0.2 s later the camera takes a VGA photo - /photo1.jpg on the
card - and the relay switches the porch light on for 10 s. The page now shows the latest photo; SNAP takes one now,
LIGHT switches the porch light, photo1, photo2 ... open each photo and LIVE (/capture) a picture straight from the
camera. The monitor takes SNAP, LIGHT, LIST (the files on the card) and STATUS. The modules' supplies: in the demo the
PIR's and the relay's VCC go to Proteus' power rail (power terminals) - their models read the supply as a digital level;
on a real board the PIR sits on 5V and the relay on its own 5 V supply.

THE PINS (the label on the board, what it can do in the simulation)
  5V, GND, 3V3       5 V in, ground, 3.3 V
  VCC                a supply output (3.3 V; the real board's 0-ohm link picks 3.3 V or 5 V)
  IO0                GPIO (the camera's XCLK on the real board; LOW at reset = flash mode)
  IO2, IO4, IO12 .. IO15  GPIO, interrupt, analogWrite, analogRead (ADC2 on the real ESP32: not while Wi-Fi is on); IO4
  is also
                     the flash LED; on the real board the microSD card uses 2, 4, 12 .. 15 (1-bit mode: 2, 14, 15)
  IO16               GPIO (the PSRAM's on the real board)
  U0R / U0T          Serial (GPIO3 / GPIO1): the FTDI adapter's - the board's monitor here
  GPIO33             the red LED on the back (LED_BUILTIN, lit when LOW; a hidden pin of the board's own)
The camera's pins (5, 18 .. 27, 32, 34 .. 39) are on the board, not on the header: the camera is the board model's.

PROPERTIES (double-click the board > Edit Properties)
  PROGRAM    the sketch's HEX (Arduino IDE: Sketch > Export Compiled Binary with AI Thinker ESP32-CAM (TEP Proteus))
  CAMSCENE   what the camera sees: PORCH (a front door at night; the flash lights it), DESK or TESTCARD
  CAMMOTION  the GPIO that brings a visitor into the picture while it is HIGH (13 = the PIR on IO13), or NONE
  SDCARD     the card: 4GB, 8GB, 16GB, 32GB, or NO (an empty slot: SD_MMC.begin() fails)
  SDFOLDER   a folder on your PC that gets a copy of every file written to the card (empty = none)
  WIFISSID, WIFIPASS  the router;  MONITOR, BAUD, AUTOOPEN  the serial monitor;  TIME  the clock for NTP
Several ESP32-CAMs in one design are fine: each has its own camera, card and serial monitor.

TROUBLESHOOTING
* Nothing happens at Run: the HEX was not built with TEP Boards for Proteus - select AI Thinker ESP32-CAM (TEP Proteus)
  and export the binary again.
* "Camera init failed": esp_camera_init() got no answer - the board must be the ESP32-CAM (another TEP board has no
  camera).
* The sketch stops after SD_MMC.begin(): int is 16 bits here - SD_MMC.cardSize() / (1024 * 1024) divides by 0 (1024 *
  1024 overflows). Write SD_MMC.cardSize() / 1048576UL. The same for every big constant: use L or UL.
* "Card Mount Failed": the board's SDCARD property is NO.
* The photo is dark: the porch is at night - switch the flash (GPIO4) on before esp_camera_fb_get(), as the demo does.
* No visitor in the picture: CAMMOTION must be the GPIO the PIR's OUT is wired to, and that pin HIGH when the picture is
  taken.
* The laptop shows "The picture did not load": the page's <img src> must be on the same board (a path like /latest.jpg).

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot and the Serial Monitor text:
  https://www.theengineeringprojects.com/forum/category/esp32-cam-proteus-library

LICENCES AND THIRD-PARTY NOTES
* The board model, the camera, the card and the network (TEPNET.DLL), the symbols and artwork (TEPESP32CAM.LIB,
  TEPLAPTOP.LIB, TEPMOBILE.LIB) and the module models (TEPHCSR501, TEPRELAY) are made by The Engineering Projects. The
  board's processor is Proteus's own ATmega2560 model. The source code of the models is not included.
* TEP Boards for Proteus (Arduino Code): its core, the variants and the EEPROM, SPI and Wire libraries are modified
  copies of the Arduino AVR core 1.8.6 - GNU Lesser General Public License 2.1 (LGPL 2.1, the text:
  LICENSE-LGPL-2.1.txt); its esp32-camera and SD_MMC libraries (written by us with Espressif's and the ESP32 core's
  names), WiFi, WebServer, its other libraries and our core files are MIT (LICENSE-MIT.txt).
* Proteus is a product of Labcenter Electronics and is not included. ESP32 is a trademark of Espressif Systems;
  ESP32-CAM is AI-Thinker's board; OV2640 is a name of OmniVision. This library is not made or endorsed by them or by
  Labcenter.

REBUILDING THE FIRMWARE (OPTIONAL)
The HEX file is supplied. Install TEP Boards for Proteus (INSTALLATION step 5), open Arduino Code\ESP32CAM_PIR_Snapshot,
select AI Thinker ESP32-CAM (TEP Proteus) and use Sketch > Export Compiled Binary. For a real ESP32-CAM select "AI
Thinker ESP32-CAM" (Espressif's ESP32 boards package; Tools > PSRAM: Enabled), wire an FTDI adapter to U0R / U0T (IO0 to
GND while it uploads) and upload - the same sketch takes real pictures.

MODEL SCOPE AND LIMITS
Modelled: the ESP32-CAM's header pins on a hidden ATmega2560 (Proteus's AVR model, 16 MHz, 3.3 V); digital I/O,
analogRead, PWM (analogWrite / ledc) and attachInterrupt on the header GPIOs through the board model; the flash LED on
GPIO4, the red LED on GPIO33; Serial on U0T / U0R (the board's monitor); Wi-Fi (station, the WebServer, WiFiClient) with
our network; the OV2640 as JPEG frames from the model's scenes (the frame sizes 96 x 96 .. 1600 x 1200, the quality,
brightness, contrast, saturation, the special effects, mirror, flip, colour bars); the microSD card with its files and
folders (8 open at once). Not modelled: the ESP32 itself (240 MHz, 520 KB RAM, the PSRAM), raw pixel formats (RGB565,
grayscale: frames are JPEG and fb->buf cannot be read in the sketch), pictures over 64 KB (the model encodes a bigger
frame again at a lower quality), the camera's exposure, gain and white balance controls (accepted and logged), face
detection, Bluetooth, the RST button and the red LED on the back (the LED is a hidden pin), the microSD card's pins (the
card is the model's, whatever the pins do), the IPEX antenna switch. Upload over the FTDI adapter is not used (Proteus
loads the HEX). The simulation runs below real time.

VERSION
TEP ESP32-CAM library V1.0 (Oct 2026). Device AI-THINKER ESP32-CAM (TEPESP32CAM.LIB / TEPNET.DLL), TEP Boards for
Proteus 1.37.0 (adds the ESP32-CAM, esp32-camera and SD_MMC). Demo sketch ESP32CAM_PIR_Snapshot V1.0. Demo parts:
HC-SR501 PIR and relay module (the Advance versions), LAPTOP WIFI MONITOR and MOBILE WIFI MONITOR.