Sistema di video sorveglianza con ESP32 CAM

Introduzione

Sul mercato sono presenti diversi modelli di schede che montano il microcontrollore ESP32, adatte a diverse applicazioni, come per esempio la scheda ESP32 CAM, che ha in dotazione una camera e un lettore di schede SD.

Questo modello può essere utilizzato per applicazioni di video sorveglianza, Computer Vision o in agricoltura, grazie all’intelligenza artificiale, è possibile eseguire dei test sulle piante per le valutazioni di eventuali malattie ecc.

In questo articolo farò un’introduzione del modello ESP32 CAM e analizzerò il codice per realizzare una webcam per la video sorveglianza, in seguito utilizzeremo questa board per altre applicazioni.

Caratteristiche della board ESP32-CAM

La scheda ESP32 CAM, come si può osservare dalla Figura 1, non ha un’interfaccia USB per la programmazione del micro, come molti modelli presenti sul mercato.

Questa scelta, molto probabilmente, è stata indotta per ridurre le dimensioni della scheda e diminuire i costi di produzione e di vendita.

Nel seguito dell’articolo, vedremo come programmare la scheda grazie all’utilizzo di un convertitore USB to RS232.

Sulla parte superiore del PCB è presente un piccolo diodo LED, ad alta efficienza, connesso ad un driver che può essere comandato dl microcontrollore.

Seppur il diodo integrato sulla scheda è ad alta efficienza esso non è in grado di illuminare un’ampia superfice, poiché la potenza che riesce ad erogare non è sufficientemente elevata, altrimenti sarebbe stato necessario montare un dissipatore sul case del diodo LED, per dissipare il calore prodotto.

Per i motivi sopracitati nel caso in cui si volesse usare la scheda ESP32 CAM anche per la video sorveglianza notturna, consiglio di usare una lampada di maggiore potenza che si attiva con la rilevazione di presenza.

Per ampliare la copertura del WI-FI , sulla scheda ESP32 CAM, è presente un connettore, evidenziato nella Figura 3, per connettere un’antenna esterna.

Di seguito sono riportate le caratteristiche principale della scheda:

802.11b/g/n Wi-Fi
Bluetooth 4.2 con BLE
UART, SPI, I2C e PWM
Clock fino a 160 MHz
Capacità di calcolo fino a 600 DMIPS
520 KB SRAM e 4 MB PSRAM
Supporto per Upload immagine WiFi
Multi Sleep modes
Firmware Over the Air (FOTA)
9 GPIO ports
Flash LED

La camera fornita a corredo della scheda ESP32 CAM è il modello OV2640, sul mercato sono presenti altri modelli come OV7670, che ha caratteristiche superiori. La camera OV2640 ha le seguenti caratteristiche:

Sensore da 2 Megapixel
L’array 1622×1200 UXGA
I formati supportati: YUV422, YUV420, RGB565, RGB555.
Il numero di frame è compreso tra 15 a 60 fps

Programmazione di ESP32 CAM

La scheda ESP32 CAM, non ha una porta USB, come accennato in precedenza, pertanto per programmare il microcontrollore è necessario usare una scheda FTDI, nella Figura 5, è riportato lo schema di connessione.

Il microcontrollore ESP32 è alimentato a 3.3V, quindi, le sue uscite sono compatibili con i livelli logici CMOS 3.3 V Figura 4.

Prima di procedere alla programmazione della scheda bisogna cortocircuitare il pin GPIO 0 a GND per poi scollegarlo a fine programmazione. I pins GPIO1 e GPIO3 sono i pins dedicati alla comunicazione seriale e per la programmazione del microcontrollore.

La tensione d’alimentazione della scheda ESP32 CAM, come da schema in Figura 5, è prelevata direttamente della scheda FTDI.

Consiglio, dopo la programmazione di usare un alimentatore esterno poiché la scheda ESP32 quando si connette al WIFI ha un assorbimento di corrente relativamente alta, e quella erogata dalla FTDI potrebbe non essere sufficiente.

Una volta connessa la scheda FTDI tra PC e ESP32 CAM si può procedere alla programmazione con l’ambiente di sviluppo di Arduino, opportunamente configurato con le librerie di ESP32, caricando il link (https://dl.espressif.com/dl/package_esp32_index.json) come da indicazioni nella GIF di seguito.

Per questo progetto caricheremo, il codice d’esempio presente nell’ambiente di sviluppo di Arduino, dopo aver caricato le librerie di esp32, seguite la procedura riportata nella GIF di seguito.

Il codice completo, senza gli include e’ riportato di seguito:

#include "esp_camera.h"
#include <WiFi.h>

//
// WARNING!!! Make sure that you have either selected ESP32 Wrover Module,
//            or another board which has PSRAM enabled
//

// Select camera model
//define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

#include "camera_pins.h"

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

void startCameraServer();

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

  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_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

#if defined(CAMERA_MODEL_ESP_EYE)
  pinMode(13, INPUT_PULLUP);
  pinMode(14, INPUT_PULLUP);
#endif

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

  sensor_t * s = esp_camera_sensor_get();
  //initial sensors are flipped vertically and colors are a bit saturated
  if (s->id.PID == OV3660_PID) {
    s->set_vflip(s, 1);//flip it back
    s->set_brightness(s, 1);//up the blightness just a bit
    s->set_saturation(s, -2);//lower the saturation
  }
  //drop down frame size for higher initial frame rate
  s->set_framesize(s, FRAMESIZE_QVGA);

#if defined(CAMERA_MODEL_M5STACK_WIDE)
  s->set_vflip(s, 1);
  s->set_hmirror(s, 1);
#endif

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");

  startCameraServer();

  Serial.print("Camera Ready! Use 'http://");
  Serial.print(WiFi.localIP());
  Serial.println("' to connect");
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(10000);
}

Se usate la camera la board indicata in questo progetto, ed è quella più diffusa sul mercato, dovete impostare le define come riportato di seguito:

In questa parte del codice bisogna inserire l’ID e la Password del vostro WIFI

In questa sezione del codice configuriamo i pins del microcontrollore connessi alla camera.

Ci connettiamo al wifi e lanciamo il web serve con tutte le configurazioni della camera.

Dopo la programmazione della scheda ESP32 CAM, sul terminale della seriale, integrato verra’ stampato l’indirizzo IP per connettersi alla scheda e configurare la camera.