Introduzione
Ai giorni nostri abbiamo tutti a che fare con sistemi di videosorveglianza: nelle strade, nei negozi, in casa (per controllare accessi indesiderati di eventuali malintenzionati o magari per osservare di nascosto il comportamento dei nostri amici pelosi in nostra assenza). L’odierna tecnologia ci viene in aiuto in quanto ci fornisce schede, fotocamere e sistemi di storage sempre più miniaturizzati ed economici. Pensiamo solo alle dimensioni (e al costo) delle videocamere di qualche decina di anni fa!
Oggi abbiamo a disposizione schede capaci di gestire una piccolissima fotocamera, di collegarsi alla rete Internet tramite WiFi e di inviarci le immagini riprese in tempo reale, senza bisogno della nostra presenza.
Una di queste schede è la Freenove basata su chip ESP32-WROVER dotata di una minuscola ma efficace fotocamera:
Come detto, la scheda è dotata di una fotocamera modello OV2640 capace di riprendere immagini ferme e in movimento.
Di che componenti abbiamo bisogno?
Semplicemente della scheda Freenove ESP32-WROVER CAM Board con fotocamera, acquistabile su Amazon a questo link.
Come è fatto il nostro sistema di videosorveglianza?
La realizzazione è molto semplice in quanto, come detto sopra, l’unico hardware che ci serve è la scheda completa di fotocamera e il solito cavetto USB necessario per collegarla al PC e programmarla.
Una volta caricato il firmware bisognerà configurare la scheda in modo che si connetta alla nostra rete WiFi. Una volta che la scheda è connessa, ci fornirà la sua URL tramite il Serial Monitor. Non ci resta quindi che aprire quell’URL nel nostro browser e vedere le immagini riprese.
Creiamo il progetto per lo sketch su PlatformIO
Abbiamo già visto in un articolo precedente come creare un progetto usando l’ottimo IDE PlatformIO. Creiamo quindi il nostro progetto seguendo le indicazioni dell’articolo Come creare un progetto per NodeMCU ESP8266 con PlatformIO. Anche se si riferisce alla scheda ESP8266, la procedura è simile.
Semplicemente, nella scelta della piattaforma dovremo scegliere la Espressif ESP-WROVER-KIT.
Saltiamo pure la parte su come aggiungere le librerie al progetto in quanto l’unica che ci serve (WifiManager) la aggiungeremo in maniera diversa.
Il file platformio.ini, che troverai nel progetto scaricabile dal link più sotto, lo dovrai modificare in modo che contenga le seguenti righe (dopo l’intestazione commentata):
[env:esp-wrover-kit]
platform = espressif32
board = esp-wrover-kit
framework = arduino
monitor_speed = 115200
upload_speed = 921600
board_build.partitions = huge_app.csv
build_flags = -DBOARD_HAS_PSRAM
lib_deps = https://github.com/tzapu/WiFiManager.git
Con queste impostazioni stiamo definendo la piattaforma (esp-wrover-kit), la velocità del Serial Monitor (115200), la velocità di caricamento dello sketch (921600), il tipo di partizione di memoria da usare (huge_app.csv), la presenza di una PSRAM (-DBOARD_HAS_PSRAM) e la libreria WiFiManager direttamente dal suo repository (https://github.com/tzapu/WiFiManager.git).
Ma siccome un video è più esplicativo di mille parole, ecco qui sotto il video su come creare il progetto:
Mentre dal link sottostante potrai scaricare il progetto:
Sovrascrivi il file main.cpp con quello appena scaricato e copia nella cartella src il file app_httpd.cpp e nella cartella include i file camera_index.h e camera_pins.h.
Compila ora il progetto e caricalo sulla scheda. Se non ci sono errori, il prossimo passo sarà quello di connettere la scheda alla rete WiFi.
Come connettere la scheda ad Internet
Dopo aver caricato lo sketch sulla scheda, apri il Serial Monitor per vedere i messaggi provenienti dal dispositivo.
Per prima cosa la scheda va in modalità Access Point e ci fornirà un indirizzo IP che useremo a breve. Questa operazione serve per connettere la scheda ad Internet senza dover inserire nel codice i parametri della rete WiFi (SSID e password).
In questo caso l’indirizzo IP è 192.168.4.1.
A questo punto la Freenove è in modalità Access Point (con SSID AutoConnectAP) e dobbiamo connettere il nostro computer alla rete AutoConnectAP. Se andiamo nel menu delle reti del nostro computer, dovremmo vedere anche la rete AutoConnectAP nell’elenco delle reti wireless.
Connetti il computer alla rete AutoConnectAP. Quindi vai sul tuo browser e inserisci l’IP precedentemente fornito dalla Freenove: 192.168.4.1
Vedrai una schermata come questa:
Clicca il bottone ConfigureWiFi. Ti mostrerà le reti disponibili:
Scegli la SSID della tua rete:
Inserisci la password della tua rete e clicca il bottone save:
Il modulo Freenove conserva memorizzati i parametri di accesso anche se lo spegni, li ricorderà al riavvio e si ricollegherà automaticamente senza dover ripetere questa procedura. Solo se lo resetti rimuovendo il commento da questa riga
// wm.resetSettings();
perderà i parametri di connessione.
Nota Bene: il dispositivo può memorizzare solo una rete. Se successivamente lo colleghi a un’altra rete, dimenticherà le impostazioni della rete precedente.
Una volta connessa, la scheda ci fornisce il suo IP e l’URL che dobbiamo aprire sul browser:
Il video successivo mostra più in dettaglio il funzionamento:
Come si può vedere dall’ultima parte del video, la fotocamera ha molti controlli:
Si va dalla scelta della risoluzione ai classici controlli di luminosità, contrasto, colore, saturazione e così via.
Lo sketch
Come al solito lo sketch inizia con l’inclusione delle librerie necessarie:
#include <Arduino.h>
#include "esp_camera.h"
#include <WiFiManager.h>
Segue poi la definizione del tipo di camera:
#define CAMERA_MODEL_WROVER_KIT // Has PSRAM
Viene poi incluso il file camera_pins.h che si trova nella cartella include:
#include "camera_pins.h"
camera_config_t config;
void startCameraServer();
void config_init();
viene definito l’oggetto config, per la configurazione della camera, e vengono dichiarate le due funzioni startCameraServer e config_init.
La funzione setup contiene la parte relativa alla attivazione della porta seriale, la gestione del WiFi:
WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
// it is a good practice to make sure your code sets wifi mode how you want it.
Serial.begin(115200);
//WiFiManager, Local intialization. Once its business is done, there is no need to keep it around
WiFiManager wm;
// reset settings - wipe stored credentials for testing
// these are stored by the esp library
// wm.resetSettings();
// Automatically connect using saved credentials,
// if connection fails, it starts an access point with the specified name ( "AutoConnectAP"),
// if empty will auto generate SSID, if password is blank it will be anonymous AP (wm.autoConnect())
// then goes into a blocking loop awaiting configuration and will return success result
bool res;
// res = wm.autoConnect(); // auto generated AP name from chipid
// res = wm.autoConnect("AutoConnectAP"); // anonymous ap
res = wm.autoConnect("AutoConnectAP","password"); // password protected ap
if(!res) {
Serial.println("Failed to connect");
// ESP.restart();
}
else {
//if you get here you have connected to the WiFi
Serial.println("Connected...yeey :)");
}
e l’impostazione della fotocamera con la stampa dell’URL da aprire:
config_init();
// 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;
} else {
Serial.println("Camera init OK");
}
sensor_t * s = esp_camera_sensor_get();
s->set_vflip(s, 0); //1-Upside down, 0-No operation
s->set_hmirror(s, 0); //1-Reverse left and right, 0-No operation
s->set_brightness(s, 1); //up the blightness just a bit
s->set_saturation(s, -1); //lower the saturation
startCameraServer();
Serial.print("Camera Ready! Use 'http://");
Serial.print(WiFi.localIP());
Serial.println("' to connect");
La funzione loop non ci serve quindi è vuota.
Alla fine dello sketch troviamo la funzione config_init:
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.frame_size = FRAMESIZE_QVGA;
config.pixel_format = PIXFORMAT_JPEG; // for streaming
//config.pixel_format = PIXFORMAT_RGB565; // for face detection/recognition
config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
config.fb_location = CAMERA_FB_IN_PSRAM;
config.jpeg_quality = 12;
config.fb_count = 1;
che non fa altro che configurare i pin della camera collegati al modulo ESP32 e altri parametri relativi al tipo di immagine prodotta.
Considerazioni finali
La camera utilizzata è teoricamente in grado (ma queste funzioni non sono state da noi testate) di svolgere anche funzioni di face detection/recognition.
Come abbiamo visto, il browser si collega alla camera tramite l’URL http://ip dove ip è l’IP del dispositivo. Questo IP è relativo alla rete interna (per esempio del router nella nostra casa) quindi non è visibile dall’esterno, cioè se il nostro PC è collegato ad una rete esterna (come quando, per esempio, siamo fuori casa).
Per poterlo fare dovremmo avere prima di tutto un IP del dispositivo statico (in modo che non cambi mai). In generale alla scheda viene assegnato sempre lo stesso IP (a meno che non sia stato già assegnato a qualche altro dispositivo) quindi questo non dovrebbe essere un grosso problema. Per rendere però visibile all’esterno questo IP interno, è necessario utilizzare il cosiddetto port forwarding che permette di dare l’accesso dall’esterno a un dispositivo della rete locale che ha un indirizzo privato.
Newsletter
Se vuoi essere aggiornato sui nuovi articoli, iscriviti alla newsletter. Prima dell’iscrizione alla newsletter leggi la pagina Privacy Policy (UE)
Se ti vuoi disiscrivere dalla newsletter clicca sul link che troverai nella mail della newsletter.