Search Code

ESP32 ટ્યુટોરિયલ 44/55 - ESP32 કેમેરા વેબ સર્વર વિડિયો સ્ટ્રીમ વાઇફાઇ CAM-2 પર | SunFounder ની ESP32 કિટ

ESP32 ટ્યુટોરિયલ 44/55 - ESP32 કેમેરા વેબ સર્વર વિડિયો સ્ટ્રીમ વાઇફાઇ CAM-2 પર | SunFounder ની ESP32 કિટ

આ ટ્યુટોરિયલમાં, આપણે ESP32 અને તેના કેમેરા એક્સટેન્શનનો ઉપયોગ કરીને રીઅલ-ટાઇમ હવામાન સ્ટેશન બનાવીશું. આ પ્રોજેક્ટ ESP32 ને LCD સ્ક્રીન પર તાપમાન અને ભેજ જેવો હવામાન ડેટા દર્શાવવા સક્ષમ બનાવશે, સાથે જ Wi-Fi પર વિડિયો સ્ટ્રીમિંગ પણ કરશે. આ ટ્યુટોરિયલના અંત સુધીમાં, તમારી પાસે સંપૂર્ણ કાર્યક્ષમ હવામાન સ્ટેશન હશે જે દર 10 સેકન્ડે અપડેટ થાય છે, જે તમને તમારી આંગળીના ટેરવે મૂલ્યવાન હવામાન માહિતી પ્રદાન કરે છે. વધુ સ્પષ્ટતા માટે, વિડિયોનો સંદર્ભ લો (વિડિયોમાં 00:00 પર).

extension_bopard_camera

હાર્ડવેર સમજાવ્યું

આ પ્રોજેક્ટના મુખ્ય ઘટકોમાં ESP32 માઇક્રોકંટ્રોલર, LCD ડિસ્પ્લે અને કેમેરા મોડ્યુલનો સમાવેશ થાય છે. ESP32 એક શક્તિશાળી માઇક્રોકંટ્રોલર છે જેમાં બિલ્ટ-ઇન Wi-Fi અને બ્લૂટૂથ ક્ષમતાઓ છે, જે તેને ઇન્ટરનેટ સાથે જોડાવા અને અન્ય ઉપકરણો સાથે સંચાર કરવાની મંજૂરી આપે છે. કેમેરા મોડ્યુલ વિડિયો સ્ટ્રીમિંગ સક્ષમ બનાવે છે, જ્યારે LCD ડિસ્પ્લે વપરાશકર્તાને હવામાન માહિતી રજૂ કરે છે.

આ પ્રોજેક્ટમાં વપરાયેલ LCD એ 20x4 અક્ષર ડિસ્પ્લે છે, જે એક સાથે નોંધપાત્ર માહિતી દર્શાવી શકે છે. તે તાપમાન, ભેજ અને ઓનલાઇન API માંથી મેળવેલો અન્ય હવામાન ડેટા દર્શાવવા માટે ESP32 સાથે જોડાયેલ છે. ESP32 માં બેટરી મેનેજમેન્ટ સિસ્ટમ પણ શામેલ છે, જે તેને વાયરલેસ રીતે કાર્ય કરવાની મંજૂરી આપે છે.

ડેટાશીટ વિગતો

ઉત્પાદક Espressif
ભાગ નંબર ESP32-WROOM-32
લોજિક/IO વોલ્ટેજ 3.3 V
સપ્લાય વોલ્ટેજ 3.0 - 3.6 V
આઉટપુટ કરંટ (પ્રતિ GPIO) 12 mA
પીક કરંટ (પ્રતિ GPIO) 40 mA
PWM ફ્રીક્વન્સી માર્ગદર્શન 1 kHz
ઇનપુટ લોજિક થ્રેશોલ્ડ 0.3 * VDD થી 0.7 * VDD
વોલ્ટેજ ડ્રોપ / RDS(on) / સેચ્યુરેશન 0.1 V (સામાન્ય)
થર્મલ મર્યાદાઓ 125 °C
પેકેજ QFN48
નોંધો / વેરિઅન્ટ્સ PSRAM વિકલ્પો શામેલ છે

 

  • યોગ્ય પાવર સપ્લાય (3.0 - 3.6 V) સુનિશ્ચિત કરો.
  • ઉચ્ચ કરંટ એપ્લિકેશનો માટે હીટ સિંકનો ઉપયોગ કરો.
  • GPIO કરંટ મર્યાદાઓ (12 mA પ્રતિ પિન) વિશે સાવચેત રહો.
  • ખોટા સંચાર ટાળવા માટે LCD અને કેમેરાને યોગ્ય રીતે જોડો.
  • કનેક્ટિવિટી સમસ્યાઓ માટે Wi-Fi ઓળખપત્રો અને API કીઓ તપાસો.

વાયરિંગ સૂચનાઓ

ESP32 ને LCD અને કેમેરા મોડ્યુલ સાથે વાયર કરવા માટે, પાવર અને ગ્રાઉન્ડ પિન જોડીને શરૂ કરો. ESP32 ના ગ્રાઉન્ડ પિનને LCD અને કેમેરાના ગ્રાઉન્ડ સાથે જોડો. પછી, ESP32 ના 5V પિનને LCD ના VCC સાથે જોડો. કેમેરા માટે, ભૂરા વાયરને ગ્રાઉન્ડ સાથે, લાલ વાયરને 5V સાથે, પીળા વાયરને GPIO 21 સાથે અને નારંગી વાયરને GPIO 22 સાથે જોડો. ખાતરી કરો કે ઓપરેશન દરમિયાન કોઈ સમસ્યા ન આવે તે માટે જોડાણો સુરક્ષિત છે.

આગળ, LCD ને યોગ્ય GPIO પિન સાથે જોડો. ચોક્કસ પિન તમારા સેટઅપના આધારે બદલાઈ શકે છે, પરંતુ સામાન્ય રીતે, તમે કંટ્રોલ પિનને ESP32 પર નિયુક્ત GPIO સાથે જોડશો. યોગ્ય વાયરિંગની પુષ્ટિ કરવા માટે તમારા ચોક્કસ LCD મોડેલ માટે ડેટાશીટ અથવા પિનઆઉટ ડાયાગ્રામનો સંદર્ભ લેવાનું સુનિશ્ચિત કરો. આ જોડાણો પૂર્ણ કર્યા પછી, કોઈપણ છૂટક અથવા ખોટા જોડાણો માટે બધા વાયરિંગને ફરીથી તપાસો.

કોડ ઉદાહરણો અને વોકથ્રુ

કોડમાં, આપણે પહેલા કેમેરા અને Wi-Fi કાર્યક્ષમતાઓને સંભાળવા માટે જરૂરી લાઇબ્રેરીઓ શામેલ કરીએ છીએ. આવશ્યક ઓળખકર્તાઓ જાહેર કરવામાં આવ્યા છે, જેમાં Wi-Fi ઓળખપત્રો માટે ssid અને password શામેલ છે. કેમેરા માટેનું રૂપરેખાંકન camera_config_t સ્ટ્રક્ચરનો ઉપયોગ કરીને સેટ કરવામાં આવ્યું છે, જ્યાં આપણે પિક્સેલ ફોર્મેટ અને ફ્રેમ સાઇઝ જેવા વિવિધ પરિમાણો વ્યાખ્યાયિત કરીએ છીએ.

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

void setup() {
  Serial.begin(115200);
  camera_config_t config;
  // ... (રૂપરેખાંકન સેટિંગ્સ)
  esp_err_t err = esp_camera_init(&config);
  // ભૂલો માટે તપાસો
}

આ સ્નિપેટ કેમેરાને પ્રારંભ કરે છે અને સેટઅપ દરમિયાન કોઈપણ ભૂલો માટે તપાસે છે. જો કેમેરા પ્રારંભ કરવામાં નિષ્ફળ જાય, તો સીરિયલ મોનિટર પર ભૂલ સંદેશ છાપવામાં આવે છે.

આગળ, આપણે Wi-Fi કનેક્શન સંભાળીએ છીએ અને કેમેરા સર્વર શરૂ કરીએ છીએ. કનેક્શન લૂપ સફળ Wi-Fi કનેક્શન સ્થાપિત ન થાય ત્યાં સુધી ચાલુ રહે છે, જે API માંથી હવામાન ડેટા મેળવવા માટે નિર્ણાયક છે.

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  delay(500);

  Serial.print(".");
}
startCameraServer();

આ વિભાગમાં, આપણે Wi-Fi કનેક્શન શરૂ કરીએ છીએ અને કનેક્શન સ્થાપિત ન થાય ત્યાં સુધી સીરિયલ મોનિટર પર બિંદુઓ છાપીએ છીએ. એકવાર કનેક્ટ થયા પછી, કેમેરા સર્વર શરૂ થાય છે, જે વિડિયો સ્ટ્રીમિંગની મંજૂરી આપે છે.

સંપૂર્ણ કોડ લેખની નીચે લોડ થશે, જ્યાં તમે જોઈ શકો છો કે બધા ભાગો કેવી રીતે એકસાથે આવે છે.

પ્રદર્શન / શું અપેક્ષા રાખવી

એકવાર બધું વાયર થઈ જાય અને કોડ અપલોડ થઈ જાય, તો તમે અપેક્ષા રાખી શકો છો કે ESP32 Wi-Fi નેટવર્ક સાથે જોડાશે અને દર 10 સેકન્ડે હવામાન ડેટા મેળવવાનું શરૂ કરશે. તાપમાન અને ભેજ રીડિંગ્સ LCD સ્ક્રીન પર દર્શાવવામાં આવશે. વધુમાં, કેમેરા Wi-Fi પર વિડિયો સ્ટ્રીમ કરશે, જે સીરિયલ મોનિટરમાં છાપેલા સ્થાનિક IP સરનામા દ્વારા ઍક્સેસ કરી શકાય છે. જો Wi-Fi કનેક્શન નિષ્ફળ જાય, તો ESP32 તમને સીરિયલ આઉટપુટ દ્વારા સૂચિત કરશે (વિડિયોમાં 10:00 પર).

વિડિયો સમયસ્ટેમ્પ્સ

  • 00:00 શરૂઆત
  • 1:42 ESP32-Cam નો પરિચય
  • 4:30 Arduino કોડ સમજાવ્યો
  • 7:35 Arduino IDE માં ESP32 બોર્ડ અને COM પોર્ટ પસંદ કરવું
  • 9:17 પ્રદર્શન
  • 12:06 મોબાઇલ ફોન પર પ્રદર્શન

Images

ESP32-40-micro-sd-card-2
ESP32-40-micro-sd-card-2
extension_bopard_camera
extension_bopard_camera
845-ESP32 Tutorial 44/55- Arduino code for camera web sever
Language: C++
#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);
}

Resources & references

Files📁

No files available.