De AI-Thinker ESP32_camera module



Het eerste wat me opviel was dat er blijkbaar meerder ESP32 cam types zijn. O.a. de ESP32 CAM OV2640 2MP Type C of Grove CP2104 USB TTL Development Board, en de veel komende versie gewoon aangeduid als ESP32-Cam. Verder ook nog een ESP32 cam van RS die op een standaard ESP6266 lijkt.
Veel IO poorten van de ESP zijn gebruikt voor een camera. Ook daar blijken verschillende camera's met verschillende aansluitingen voor gebruikt te worden. Er is o.a. de OV2640 camera die veel meegeleverd wordt. Handig om te weten als je een ESP32 cam wil gaan bestellen.
Wat je bij de meest gangbare ESP32 cam IC's mist is de USB aansluiting. Dus weer met de FTDI en alle daarbij voorkomende problemen werken. Aan beide zijde zitten op de printplaat onderdelen. Ook zit er een sd kaart lezer en een camera met flash (flitslicht) aansluiting op de ESP32. Er zit een vierhoekje aan de onderzijde waar je een verbinding moet solderen voor het gebruik van interne antene of externe antene.
Specificaties van de ESP32 cam is vrijwel gelijk aan de ESP32.(met uitzondering dus van de USB aansluiting en camera)

802.11b/g/n Wi-Fi
Bluetooth 4.2 with BLE
UART, SPI, I2C and PWM interfaces
Clock speed up to 160 MHz
Computing power up to 600 DMIPS
520 KB SRAM plus 4 MB PSRAM
Supports WiFi Image Upload
Multiple Sleep modes
Firmware Over the Air (FOTA) upgrades possible
9 GPIO ports
Built-in Flash LED


De OV2640 camera:

2 Megapixel sensor
Array size UXGA 1622×1200
Output formats include YUV422, YUV420, RGB565, RGB555 and 8-bit compressed data
Image transfer rate of 15 to 60 fps

Een ESP met een afmeting van 27*40.5*4.5mm en in de diepe slaap modus een gebruik heeft van 6mA.
De camera kan ingezet worden in diverse IoT projecten. 'Sky is the limmit' maar hier gaat dat verder want nu kan je draadloos over 802.11b/g/n Wi-Fi, de beelden verzenden.
De module beschikt over bleutooth 4.2 en WiFi en beschikt over 520 kb Sram.

Onder de metalen plaat is de ruimte voor de SDkaart. Hou er rekening mee dat de ESP32 soms meer vermogen wil trekken via de USB/FTDI dan de PC kan leveren. Tijdens het laden van de sketch kan dat een probleem gaan geven. Heb ik niets van gemerkt maar ik gebruik de 5V uitgang van de FTDI en de 5V ingang van de ESP32 bij het laden van de sketch. Bij de Arduino IDE ->bestand ->voorkeuren ->meer board managers->,https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json<- aanvullen met komma voor het ESP32 board. Vergeet niet een eventuele jumper bij de FTDI op 3.3V te zetten i.p.v. 5V.

De bekabeling zoals de afbeelding van randomnerdtutorials. De grijze kabel van IO0 naar gnd is nodig tijdens het programeren en daarna niet meer.
Sluit de module aan en verander in de Arduino IDE het board naar ESP Wrover Module
Uploadspeed 921600
Flash freq 80 mHz
Flash mode QIO
Partition Schema Hug App (3MB No Qta)
Core debug none

De externe antene of de interne antene kan je zelf kiezen. De groene lijn bij de antene aansluiting is de verbinding met de externe antene en de rode lijn met de interne antene.

Mijn eerste ervaring met de ESP32 is met de ESP32CAM.
Een onboard camera met gezichts herkenning.
De ESP32CAM heeft geen USB aansluiting dus weer de FTDI232 pakken om de ESP32Cam van data te voorzien. Die had ik al weer een hele tijd geleden gebruikt dus eerst maar weer de juiste drivers instaleren.
Met mijn telefoon vergrootglas (camera) een foto gemaakt van het IC Het is lastig om zonder camera in een speciale hoek tegen het licht, het IC te lezen. Maar blijkt gewoon een standaard IC te zijn FT232R.
De VCC is een voeding UITgang die 3.3V geeft. Je voedt de ESP32 cam met de 3.3V of 5V pinnen. Het beste is met 5V te voeden. Wil je een 5V uitgang hebben, dan zitten er bij de VCC pin een paar jumpers die je los en weer vast moet solderen.
GPIO 0 bepaald of de ESP in FLASH mode is of niet, intern is deze GPIO verbonden via een 10K weerstand aan de plus. GPIO 0 aan massa is dus FLASHmode. Normal mode is dus een losse GPIO0.
GPIO 1 en GPIO 3 heb je nodig als TX en RX om de data op de ESP32Cam te zetten.
GPIO 2 wordt gebruikt voor SDkaart, data0.
GPIO 4 wordt gebruikt voor SDkaart, data1 en flitslicht. (kan problemen geven bij SD kaart en flitslicht gebruik.)
GPIO 12 wordt gebruikt voor SDkaart, data2
GPIO 13 wordt gebruikt voor SDkaart, data3
GPIO 14 wordt gebruikt voor SDkaart, CLK.
GPIO 15 wordt gebruikt voor SDkaart, CMD.
Volgens randomnerds kan je het probleem met SDkaart en flitslicht voorkomen door SD_MMC.begin("/sdcard", true) op te nemen. Maar het flits effect blijkt wel aan te blijven maar geeft minder licht.
GPIO 0 wordt gebruikt voor camera, XCLK.
GPIO 5 wordt gebruikt voor camera, D0.
GPIO 18 wordt gebruikt voor camera, D1.
GPIO 19 wordt gebruikt voor camera, D2.
GPIO 21 wordt gebruikt voor camera, D3.
GPIO 22 wordt gebruikt voor camera, PCLK.
GPIO 23 wordt gebruikt voor camera, HREF.
GPIO 25 wordt gebruikt voor camera, VSYNC.
GPIO 26 wordt gebruikt voor camera, SDA.
GPIO 27 wordt gebruikt voor camera, SCL.
GPIO 32 wordt gebruikt voor camera, POWER PIN.
GPIO 33 is de interne gele led.
GPIO 34 wordt gebruikt voor camera, D6.
GPIO 35 wordt gebruikt voor camera, D7.
GPIO 39 wordt gebruikt voor camera, D5.

GPIO 16 wordt blijkbaar niet gebruikt.

De camera aansluiten op de FTDI232 volgens ROBOTZERO.ONE:
ESPCAM FTDI
3.3V op 3.3V
GND op GND
UOT op RXD
UOR op TXD
IO0 verbinden met ESP32 gnd tijdens Flashen.

kies bestand -> voorkeuren -> en vul bij 'meer boardmanagers urls:' https://dl.espressif.com/dl/package_esp32_index.json in (eventueel een komma tussen de vorige voorkeur)
restart de Arduino IDE
kies bij boards -> boardsmanager -> type achter all: ESP32 en selecteer -> ESP32 by Espressif Systems
restart de Arduino IDE
kies board -> ESP Wrover Module
kies voorbeelden -> ESP32 -> Camera -> CameraWebServer
kies bij poort -> de juiste compoort (vaak de onderste)
kies bij hulpmiddelen/tools -> partitie schema ->Huge APP (3MB No OTA)<-
druk op de reset knop (onderzijde) van de ESP32Cam.
kies opload

En nu zou het moeten uploaden maar ik krijg de melding dat het bestand/script te groot is. Bij Randomnerds hebben ze die foutmeldingen op een rijtje gezet met de oplossingen erbij.

1) Failed to connect to ESP32 timed out waiting for packet header (geen verbinding en duurt te lang) De ESP32 is niet in de Flashing mode. Vermoedelijk is de bekabeling niet goed.
It means that you haven’t selected the right partition scheme. Make sure you select the right partition scheme. In your Arduino IDE, go to Tools > Partition Scheme, select “Huge APP (3MB No OTA)“.
Het bleek dat bij mij de instelling Huge app niet juist was.
Uploaden lukt nu maar bij serial monitor lees ik:
ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x3 (DOWNLOAD_BOOT(UART0/UART1/SDIO_REI_REO_V2))
waiting for download
Tja je moet natuurlijk wel na het uploaden de verbinding tussen IO0 en gnd verwijderen anders verwacht de ESP32Cam een nieuwe sketch. De verbinding verbroken en een nieuwe reset geeft een nieuwe melding via serieel monitor:

[E][camera.c:1049] camera_probe(): Detected camera not supported.
[E][camera.c:1249] esp_camera_init(): Camera probe failed with error 0x20004
bij de oplossingen kom ik ook de melding tegen en wordt geadviseerd om de #define CAMERA_MODEL_AI_THINKER te gebruiken.
Na de upload weer een andere melding:
Brownout detector was triggered

ets Jun 8 2016 00:22:57

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:9720
ho 0 tail 12 room 4
load:0x40080400,len:6352
entry 0x400806b8


Ik verwacht echter de melding dat hij het netwerk zoekt:
Serial.print(".");
Serial.println("");
Serial.println("WiFi connected");
Omdat ik die meldingen niet krijg is er dus weer iets anders aan de hand. Ook daar is een oplossing (3) voor:
Niet genoeg spanning bij het programeren. De USB kabel kan te lang zijn(zal vermoedelijk wel kloppen), usb voeding te laag etc.
Kabel aangesloten aan de laptop en nu krijg ik tijdens het uploaden een foutmelding. Eerst maar eens een korte kabel kopen. Daarna kan ik proberen met 5V te flashen. Wordt blijkbaar vaker gedaan maar ik ben er huiverig voor.

Writing at 0x001a4000... (100 %)
Wrote 2100768 bytes (1661726 compressed) at 0x00010000 in 22.0 seconds (effective 764.2 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 119...

Writing at 0x00008000... (100 %)
Wrote 3072 bytes (119 compressed) at 0x00008000 in 0.0 seconds (effective 1638.4 kbit/s)...
Hash of data verified.

Ziet er naar uit dat alles goed ging maar toch krijg ik weer -> Brownout detector was triggered <-.
Op aanraden van randomnerdtutorials i.p.v. 3.3V de 5 Volt aansluiting op de FTDI proberen. Maar die wil helemaal geen verbinding maken. Ik krijg alleen maar .....---..... te zien. Later las ik dat je op dat moment de reset op de ESP32 moet indrukken. Dat helpt.
Met paar dagen later met verse zin een andere FTDI aangesloten en nu lijkt alles goed te gaan. Serial monitor geeft aan wat het IP adres is geworden en ik krijg op dat IP adres wat in beeld en een (1) foto maken lukt ook. Het SD kaartje even geformateerd op fat 32 Plotseling kreeg ik via serial monitor:
[E][sccb.c:154] SCCB_Write(): SCCB_Write Failed addr:0x30, reg:0x12, data:0x80, ret:-1
[E][camera.c:1049] camera_probe(): Detected camera not supported.
[E][camera.c:1249] esp_camera_init(): Camera probe failed with error 0x20004
Dus alle cameras uit proberen.
CAMERA_MODEL_WROVER_KIT geprobeerd, geeft ook foutmelding.
CAMERA_MODEL_ESP_EYE geprobeerd, geeft ook foutmelding.
CAMERA_MODEL_M5STACK_PSRAM, geeft ook foutmelding.
CAMERA_MODEL_M5STACK_WIDE, geeft ook foutmelding.
CAMERA_MODEL_AI_THINKER, geeft ook foutmelding.
Niet vergeten serial monitor af te sluiten en een een verbinding te maken tussen GPIO en GND om te booten. OOK NIET vergeten de SD kaart terug te zetten.
Elke camera die ik probeer te instaleren, geeft een fout melding maar als ik # randomnerdtutorials pir-motion-detector instaleer en GPIO13 aan GND verbind, wordt er een foto gemaakt en op SD kaart opgeslagen.Hier maak ik uit op dat de camera goed is en het dataoverzetten ook.
Een dump van de serial monitor eens in Google gegooid

Guru Meditation Error: Core 0 panic'ed (IllegalInstruction). Exception was unhandled.
Memory dump at 0x400e44fc: f01d020c a6971c0d 00a0c202
Core 0 register dump:
PC : 0x400e4500 PS : 0x00060e30 A0 : 0x800e4705 A1 : 0x3ffcde00
A2 : 0x0000002c A3 : 0x00000000 A4 : 0x00000001 A5 : 0x00000000
A6 : 0x0000002b A7 : 0x00000001 A8 : 0x0000001e A9 : 0x0000002a
A10 : 0x00000055 A11 : 0x0000007f A12 : 0x3ffc7ac0 A13 : 0x0000001e
A14 : 0x00000000 A15 : 0x0000002b SAR : 0x00000007 EXCCAUSE: 0x00000000
EXCVADDR: 0x00000000 LBEG : 0x4000c2e0 LEND : 0x4000c2f6 LCOUNT : 0x00000000

Backtrace: 0x400e4500:0x3ffcde00 0x400e4702:0x3ffcde60 0x400e482f:0x3ffcdeb0 0x400e2716:0x3ffcded0 0x400e2b2c:0x3ffcdef0 0x400d9d0f:0x3ffcdfb0 0x400d9fa2:0x3ffcdfe0 0x4011242c:0x3ffce010 0x4011251c:0x3ffce040 0x4011281a:0x3ffce070 0x4010ebe6:0x3ffce0a0 0x4009454b:0x3ffce0c0 0x4008db4d:0x3ffce100
Het antwoord vond ik op https://github.com/espressif/arduino-esp32/issues/2547.

This is saying that a program instruction was not valid. Usually that is a hardware issue, makes sure you don't have anything connected to to FLASH buss pins 6..11.
It could be your FLASH has a bad byte that is not correctly storing the program.
Did a decoding on the backtrace to find out it's phy related. You helped me to realize that my ESP connected to a USB hub(into a 2.1A socket thou) is struggling to turn on when my phone is charging from the same hub.

Hier steek ik weer wat van op. Blijkbaar gaat er met het data opslaan iets fout of een deel van het geheugen is defect (kan niet opgeslagen worden). Vermoedelijk bij mij het laatste. Als ik meer geugen nodig heb krijg ik de brounout melding. Dus een nieuwe ESP32 besteld.
De nieuwe ESP32 (na een paar maander wachten) aangesloten en het voorbeeld sketch doet meteen wat het belooft. Uiteraard had ik alle foutmeldingen van verkeerde instellingen al voorkomen door dat ik de instellingen nog wist. CAMERA_MODEL_AI_THINKER kiezen en beeld.
.De gezichts herkenning en gezichts detectie kan alleen in lage resolutie en werkt traag. Verder vind ik het er goed uitzien.
Heel veel steun gehad van Randomnerdtutorials.
OP https://randomnerdtutorials.com/esp32-cam-video-streaming-web-server-camera-home-assistant/ een sketch waarmee de ESP32 cam verbonden kan worden met Home Assistant. Vervolgens eens kijken hoe ik de beelden voor een maand (na 3 weken vakantie max.) kan opslaan. Beelden ouder dan 2 maanden worden gewist. (1e van de maand wissen is makkelijker dan na 29 dagen)

Na de aankoop van een 3D printer heb ik een goed doel gevonden voor mijn camera. Kijken hoever de printer is en als hij klaar is, de spanning afschakelen. Een nieuwe ESP32 bood ook de aankoop voor een ESP32-cam-M USB programeer voet. Na een aantal keren proberen daarmee de ESP te programeren kwam ik er achter dat simpelweg de ESP32cam inpluggen en USB aansluiten niet werkt. gelukkig vond ik al snel op randomnerdtutorials een uitleg en een link naar een driver voor het IC. Die CH340 had ik vermoedelijk al want ik vond de ESP32 cam die verbonden was aan mijn PC. Hier las ik dat ik geen knoppen hoefde in te drukken om de sketch te uploaden. Maar toch bleeft ik bij het uploaden ......-------...... houden.

3D printer cam

Uit eindelijk dat shield aan de kant gegooid en weer verder gegaan met de FTDI. Wonderwel ging dat nu plotseling zonder problemen.
Omdat ik geen zin heb om steeds naar het 3D camera beeld te kijken en omdat opslaan van streaming video behoorlijk wat internetverkeer opwekt, tevens serverruimte gebruikt, heb ik gekozen om elke 20 seconde een foto te uploaden. Na uploaden kijkt een script of er foto's ouder zijn dan 2 dagen en die worden verwijderd. 1 Foto elke 20 seconden is dus 3 foto's per minuut is 120 foto's per uur. Afhankelijk van het te printen object (20 uur is niets), zit je al snel op 1200 foto's voor 10 uur.
Het valt me op dat de camera redelijk wat licht nodig heeft om duidelijke foto's te maken. Elke foto is iets minder dan 25.000 pixels. De sketch een beetje aanpassen:




/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-cam-post-image-photo-server/
FTDI connection
RX to UOT
TX to VOR
GND to GND
5V to 5V
to program connect IO0 to GND on ESP32
to run leave IO0 free
A bit to personal use by P.Hogenstijn
*/

#include < Arduino.h>
#include < WiFi.h>
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include "esp_camera.h"

const char* ssid = "networkname";
const char* password = "thewordtogetin";

String serverName = "websitename";

String serverPath = "thepagetoupload";
int conn;
const int serverPort = 80;

WiFiClient client;

// CAMERA_MODEL_AI_THINKER
#define filmlamp 4
#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

const int timerInterval = 5000; // ca 5 sec. between each HTTP POST image
unsigned long previousMillis = 0; // last time image was sent

void setup()
{
conn=0;
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
Serial.begin(115200);
WiFi.mode(WIFI_STA);

Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
Serial.print(".");
delay(500);
conn++;
if (conn>100)
{
ssid = "theOthereNetWork";
password = "theWordToGetInThere";
}
}

Serial.println();
Serial.print("ESP32-CAM IP Address: ");
Serial.println(WiFi.localIP());

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_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_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;

// init with high specs to pre-allocate larger buffers
if(psramFound()){
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 10; //0-63 lower number means higher quality
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_CIF;
config.jpeg_quality = 12; //0-63 lower number means higher quality
config.fb_count = 1;
}

// Flitslight
pinMode (filmlamp, OUTPUT); //Specify that LED pin is output


// camera init
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
delay(1000);
ESP.restart();

}

sendPhoto();
}

void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= timerInterval)
{

sendPhoto();
digitalWrite (filmlamp,LOW);
previousMillis = currentMillis;

}
}

String sendPhoto()
{
String getAll;
String getBody;

camera_fb_t * fb = NULL;
fb = esp_camera_fb_get();
if(!fb) {
Serial.println("Camera capture failed");
delay(1000);
ESP.restart();
}

Serial.println("Connecting to server: " + serverName);

if (client.connect(serverName.c_str(), serverPort)) {
Serial.println("Connection successful!");
String head = "--RandomNerdTutorials\r\nContent-Disposition: form-data; name=\"imageFile\"; filename=\"Creality-cam.jpg\"\r\nContent-Type: image/jpeg\r\n\r\n";
String tail = "\r\n--RandomNerdTutorials--\r\n";

uint32_t imageLen = fb->len;
uint32_t extraLen = head.length() + tail.length();
uint32_t totalLen = imageLen + extraLen;

client.println("POST " + serverPath + " HTTP/1.1");
client.println("Host: " + serverName);
client.println("Content-Length: " + String(totalLen));
client.println("Content-Type: multipart/form-data; boundary=RandomNerdTutorials");
client.println();
client.print(head);

uint8_t *fbBuf = fb->buf;
size_t fbLen = fb->len;
for (size_t n=0; n<fbLen; n=n+1024) {
if (n+1024 < fbLen) {
client.write(fbBuf, 1024);
fbBuf += 1024;
}
else if (fbLen%1024>0) {
size_t remainder = fbLen%1024;
client.write(fbBuf, remainder);
}
}
client.print(tail);

esp_camera_fb_return(fb);

int timoutTimer = 10000;
long startTimer = millis();
boolean state = false;

while ((startTimer + timoutTimer) > millis()) {
Serial.print(".");
delay(100);
while (client.available()) {
char c = client.read();
if (c == '\n') {
if (getAll.length()==0) { state=true; }
getAll = "";
}
else if (c != '\r') { getAll += String(c); }
if (state==true) { getBody += String(c); }
startTimer = millis();
}
if (getBody.length()>0) { break; }
}
Serial.println();
client.stop();
Serial.println(getBody);
}
else {
getBody = "Connection to " + serverName + " failed.";
Serial.println(getBody);
}
return getBody;
}
Op de server verder kan je gebruim maken van het PHP script van Rui. Ik heb daar mijn tuinscript wat ik aangepast heb.
En nu kan ik wereldwijd zien wat er in mijn printerkast gebeurt.


Bronnen:
Wiki
cnx-software
Ebay
Wire-kit
autoconnect voor netwerken

ESP32
lees het document
ESP32-DevKitC V4
ESP-WROVER-KIT V3
ESP32-PICO-KIT V4

ESP32CAM
roboindia.com esp32-cam-video-streaming-and-face-recognition
robotzero.one
github.com
github.com esp32-cam-ai-thinker
github.com esp32-cam-demo
motion-detection-with-esp32-cam
randomnerdtutorials.com
esp32-cam-ai-thinker-pinout
randomnerdtutorials face-recognition-arduino-ide
randomnerdtutorials web-server-camera-home-assistant
randomnerdtutorials take-photo-save-microsd-card
randomnerdtutorials troubleshooting-guide
# randomnerdtutorials pir-motion-detector-photo-capture (deze werkt)
esp32-static-fixed-ip-address
upload-code-esp32-cam-mb-usb
blog.hackster
1 robotzero heltec-wifi-kit-32
2 robotzero esp32-camera-module
easyeda.com ESP-Cam-Programmer
Getting-Started-With-ESP32-CAM


Synology -- ESP home
circuitrocks/ESP32-RTSP
ESPhome camera instellingen
Hoe sluit je een camera aan
ONVIF_Profile