Guarda su YouTube

Tutorial ESP32 44/55 - Streaming video del server web della camera ESP32 su Wifi CAM-2 | Kit ESP32 di SunFounder

In questo tutorial, creeremo una stazione meteorologica in tempo reale utilizzando l'ESP32 e la sua estensione della fotocamera. Questo progetto permetterà all'ESP32 di visualizzare i dati meteorologici come temperatura e umidità su un display LCD, mentre trasmette anche video tramite Wi-Fi. Alla fine di questo tutorial, avrete una stazione meteorologica completamente funzionante che si aggiorna ogni 10 secondi, fornendo preziose informazioni meteorologiche a portata di mano. Per maggiore chiarezza, fare riferimento al video (nel video a :00).

Hardware Spiegato

I componenti principali di questo progetto includono il microcontrollore ESP32, un display LCD e un modulo fotocamera. L'ESP32 è un microcontrollore potente che presenta funzionalità Wi-Fi e Bluetooth integrate, permettendo di connettersi a Internet e comunicare con altri dispositivi. Il modulo fotocamera consente lo streaming video, mentre il display LCD presenta informazioni meteorologiche all'utente.

Il LCD utilizzato in questo progetto è un display a caratteri 20x4, che può mostrare una quantità significativa di informazioni contemporaneamente. È collegato all'ESP32 per visualizzare la temperatura, l'umidità e altri dati meteorologici estratti da un'API online. L'ESP32 include anche un sistema di gestione della batteria, che consente di funzionare senza fili.

Dettagli della scheda tecnica

• Garantire un'alimentazione adeguata (3,0 - 3,6 V).
• Utilizzare dissipatori di calore per applicazioni ad alta corrente.
• Fai attenzione ai limiti di corrente GPIO (12 mA per pin).
• Collega correttamente il LCD e la telecamera per evitare malintesi.
• Controlla le credenziali Wi-Fi e le chiavi API per problemi di connettività.

Istruzioni di cablaggio

Per collegare l'ESP32 al modulo LCD e alla fotocamera, inizia collegando i pin di alimentazione e massa. Collega il pin di massa dell'ESP32 alla massa del LCD e della fotocamera. Quindi, collega il pin 5V dell'ESP32 al VCC del LCD. Per la fotocamera, collega il filo marrone alla massa, il filo rosso a 5V, il filo giallo al GPIO 21 e il filo arancione al GPIO 22. Assicurati che le connessioni siano sicure per evitare problemi durante il funzionamento.

Successivamente, collegare il LCD ai pin GPIO appropriati. I pin specifici possono variare in base alla tua configurazione, ma in genere collegherai i pin di controllo ai GPIO designati sull'ESP32. Assicurati di fare riferimento al datasheet o al diagramma dei pin per il tuo modello specifico di LCD per confermare il cablaggio corretto. Dopo aver completato questi collegamenti, controlla di nuovo tutti i cablaggi per eventuali connessioni allentate o errate.

Esempi di codice e guida passo passo

Nel codice, includiamo prima le librerie necessarie per gestire le funzionalità della fotocamera e del Wi-Fi. Vengono dichiarati gli identificatori essenziali, inclusissidepasswordper le credenziali Wi-Fi. La configurazione della telecamera viene impostata utilizzando ilcamera_config_tstruttura, in cui definiamo vari parametri come il formato dei pixel e le dimensioni del frame.

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

void setup() {
  Serial.begin(115200);
  camera_config_t config;
  // ... (configuration settings)
  esp_err_t err = esp_camera_init(&config);
  // Check for errors
}

Questo frammento inizializza la fotocamera e controlla eventuali errori durante la configurazione. Se la fotocamera non riesce a inizializzarsi, viene stampato un messaggio di errore sul monitor seriale.

Successivamente, ci occupiamo della connessione Wi-Fi e avviamo il server della fotocamera. Il ciclo di connessione continua fino a quando non viene stabilita una connessione Wi-Fi di successo, fondamentale per recuperare i dati meteorologici dall'API.

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
startCameraServer();

In questa sezione, avviamo la connessione Wi-Fi e stampiamo dei punti sul monitor seriale fino a quando la connessione non viene stabilita. Una volta connesso, il server della telecamera viene avviato, consentendo lo streaming video.

Il codice completo verrà caricato sotto l'articolo, dove puoi vedere come tutte le parti si uniscono.

Dimostrazione / Cosa Aspettarsi

Una volta che tutto è cablato e il codice è caricato, puoi aspettarti che l'ESP32 si connetta alla rete Wi-Fi e inizi a raccogliere dati meteorologici ogni 10 secondi. Le letture di temperatura e umidità verranno visualizzate sullo schermo LCD. Inoltre, la telecamera trasmetterà video tramite Wi-Fi, accessibile tramite l'indirizzo IP locale stampato nel monitor seriale. Se la connessione Wi-Fi fallisce, l'ESP32 ti notificherà attraverso l'output seriale (nel video alle 10:00).

Timestamp video

• 00:00 Inizio
• 1:42 Introduzione all'ESP32-Cam
• 4:30 codice Arduino spiegato
• 7:35 Selezione della scheda ESP32 e della porta COM in Arduino IDE
• 9:17 Dimostrazione
• 12:06 Dimostrazione su telefono mobile

Immagini

ESP32-40-micro-sd-card-2

extension_bopard_camera

ESP32-40-micro-sd-card-2

extension_bopard_camera

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

//
// WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality
//            Ensure ESP32 Wrover Module or other board with PSRAM is selected
//            Partial images will be transmitted if image exceeds buffer size
//
//            You must select partition scheme from the board menu that has at least 3MB APP space.
//            Face Recognition is DISABLED for ESP32 and ESP32-S2, because it takes up from 15 
//            seconds to process single frame. Face Detection is ENABLED if PSRAM is enabled as well

// ===================
// Select camera model
// ===================
//#define CAMERA_MODEL_WROVER_KIT // Has PSRAM
// #define CAMERA_MODEL_ESP_EYE // Has PSRAM
//#define CAMERA_MODEL_ESP32S3_EYE // Has PSRAM
//#define CAMERA_MODEL_M5STACK_PSRAM // Has PSRAM
//#define CAMERA_MODEL_M5STACK_V2_PSRAM // M5Camera version B Has PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE // Has PSRAM
//#define CAMERA_MODEL_M5STACK_ESP32CAM // No PSRAM
//#define CAMERA_MODEL_M5STACK_UNITCAM // No PSRAM
#define CAMERA_MODEL_AI_THINKER // Has PSRAM
//#define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM
//#define CAMERA_MODEL_XIAO_ESP32S3 // Has PSRAM
// ** Espressif Internal Boards **
//#define CAMERA_MODEL_ESP32_CAM_BOARD
//#define CAMERA_MODEL_ESP32S2_CAM_BOARD
//#define CAMERA_MODEL_ESP32S3_CAM_LCD

#include "camera_pins.h"

// Replace the next variables with your SSID/Password combination
const char* ssid = "SSID";
const char* password = "PASSWORD";

void startCameraServer();
void setupLedFlash(int pin);

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_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_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_UXGA;
  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;
  
  // if PSRAM IC present, init with UXGA resolution and higher JPEG quality
  //                      for larger pre-allocated frame buffer.
  if(config.pixel_format == PIXFORMAT_JPEG){
    if(psramFound()){
      config.jpeg_quality = 10;
      config.fb_count = 2;
      config.grab_mode = CAMERA_GRAB_LATEST;
    } else {
      // Limit the frame size when PSRAM is not available
      config.frame_size = FRAMESIZE_SVGA;
      config.fb_location = CAMERA_FB_IN_DRAM;
    }
  } else {
    // Best option for face detection/recognition
    config.frame_size = FRAMESIZE_240X240;
#if CONFIG_IDF_TARGET_ESP32S3
    config.fb_count = 2;
#endif
  }

#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 brightness just a bit
    s->set_saturation(s, -2); // lower the saturation
  }
  // drop down frame size for higher initial frame rate
  if(config.pixel_format == PIXFORMAT_JPEG){
    s->set_framesize(s, FRAMESIZE_QVGA);
  }

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

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

// Setup LED FLash if LED pin is defined in camera_pins.h
#if defined(LED_GPIO_NUM)
  setupLedFlash(LED_GPIO_NUM);
#endif

  WiFi.begin(ssid, password);
  WiFi.setSleep(false);

  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() {
  // Do nothing. Everything is done in another task by the web server
  delay(10000);
}