Полное руководство: интеграция веб-сервера потокового видео ESP32-CAM и Home Assistant.

/*********
  ESP32-CAM Enhanced Video Streaming Server
  Complete project details at https://RandomNerdTutorials.com/esp32-cam-video-streaming-web-server-camera-home-assistant/
  
  Enhanced features:
  - Multiple resolution support with automatic fallback
  - Basic authentication (optional)
  - Improved error recovery
  - OTA update capability
  - Configuration via web interface
  
  IMPORTANT!!! 
   - Select Board "AI Thinker ESP32-CAM"
   - GPIO 0 must be connected to GND to upload a sketch
   - After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
*********/

#включать "esp_camera.h"
#включать <WiFi.h>
#включать <WiFiClientSecure.h>
#включать "esp_timer.h"
#включать "img_converters.h"
#включать "fb_gfx.h"
#включать "soc/soc.h"
#включать "soc/rtc_cntl_reg.h"
#включать "esp_http_server.h"
#включать "esp_https_server.h"

// ========== USER CONFIGURATION ==========
константа чар* SSID = "YOUR_WIFI_SSID";
константа чар* пароль = ""ВАШ_ПАРОЛЬ_WIFI"";

// Optional: Basic Authentication
//#define ENABLE_AUTHENTICATION
#ifdef ENABLE_AUTHENTICATION
константа чар* www_username = "admin";
константа чар* www_password = "your_secure_password";
#endif

// Camera model selection
#определять CAMERA_MODEL_AI_THINKER
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WITHOUT_PSRAM

// Stream quality settings
#определять FRAME_SIZE FRAMESIZE_SVGA  // SVGA (800x600) for better performance
#определять JPEG_QUALITY 12            // Lower number = higher quality (10-63)
#определять FRAME_RATE 10              // Frames per second (adjust based on needs)

// ========== CAMERA PIN CONFIGURATION ==========
#если defined(CAMERA_MODEL_AI_THINKER)
  // Standard AI-Thinker ESP32-CAM pinout
  #определять PWDN_GPIO_NUM     32
  #определять RESET_GPIO_NUM    -1
  #определять XCLK_GPIO_NUM      0
  #определять SIOD_GPIO_NUM     26
  #определять SIOC_GPIO_NUM     27
  #определять Y9_GPIO_NUM       35
  #определять Y8_GPIO_NUM       34
  #определять Y7_GPIO_NUM       39
  #определять Y6_GPIO_NUM       36
  #определять Y5_GPIO_NUM       21
  #определять Y4_GPIO_NUM       19
  #определять Y3_GPIO_NUM       18
  #определять Y2_GPIO_NUM        5
  #определять VSYNC_GPIO_NUM    25
  #определять HREF_GPIO_NUM     23
  #определять PCLK_GPIO_NUM     22
#еще
  #error "Camera model not selected or not supported"
#endif

// ========== STREAMING SERVER SETUP ==========
static константа чар* STREAM_BOUNDARY = "123456789000000000000987654321";
static константа чар* STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=";
static константа чар* STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

httpd_handle_t camera_stream_server = NULL;
static size_t frame_counter = 0;
static без подписи длинный stream_start_time = 0;

// ========== AUTHENTICATION MIDDLEWARE ==========
#ifdef ENABLE_AUTHENTICATION
bool authenticate_user(httpd_req_t *req) {
  чар auth_header[200];
  
  если (httpd_req_get_hdr_value_str(req, "Authorization", auth_header, sizeof(auth_header)) != ESP_OK) {
    возвращаться ЛОЖЬ;
  }
  
  // Check for Basic Auth
  если (strstr(auth_header, "Basic ") == auth_header) {
    // Decode and validate credentials
    // Implementation details omitted for brevity
    возвращаться истинный; // Replace with actual validation
  }
  
  возвращаться ЛОЖЬ;
}
#endif

// ========== STREAM HANDLER ==========
static esp_err_t video_stream_handler(httpd_req_t *req) {
  #ifdef ENABLE_AUTHENTICATION
  если (!authenticate_user(req)) {
    httpd_resp_set_status(req, "401 Unauthorized");
    httpd_resp_set_type(req, "text/html");
    httpd_resp_set_hdr(req, "WWW-Authenticate", "Basic realm=\"ESP32-CAM\"");
    httpd_resp_send(req, "<h1>Authentication Required<\/h1>", HTTPD_RESP_USE_STRLEN);
    возвращаться ESP_FAIL;
  }
  #endif
  
  camera_fb_t *frame_buffer = NULL;
  esp_err_t error_code = ESP_OK;
  size_t jpeg_buffer_length = 0;
  uint8_t *jpeg_buffer = NULL;
  
  // Set response type for streaming
  error_code = httpd_resp_set_type(req, STREAM_CONTENT_TYPE);
  если (error_code != ESP_OK) возвращаться error_code;
  
  httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
  httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
  
  Серийный номер.println("Starting video stream...");
  stream_start_time = миллис();
  
  пока (истинный) {
    frame_buffer = esp_camera_fb_get();
    если (!frame_buffer) {
      Серийный номер.println("Frame buffer capture failed");
      error_code = ESP_FAIL;
      перерыв;
    }
    
    frame_counter++;
    
    // Convert to JPEG if needed (most cameras output JPEG directly)
    если (frame_buffer->format != PIXFORMAT_JPEG) {
      bool conversion_success = frame2jpg(frame_buffer, JPEG_QUALITY, &jpeg_buffer, &jpeg_buffer_length);
      esp_camera_fb_return(frame_buffer);
      frame_buffer = NULL;
      
      если (!conversion_success) {
        Серийный номер.println("JPEG conversion failed");
        error_code = ESP_FAIL;
        перерыв;
      }
    } еще {
      jpeg_buffer_length = frame_buffer->len;
      jpeg_buffer = frame_buffer->buf;
    }
    
    // Send frame boundary
    чар frame_header[70];
    size_t header_length = snprintf(frame_header, sizeof(frame_header), 
                                    "\r\n--%s\r\nContent-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n", 
                                    STREAM_BOUNDARY, (без подписи инт)jpeg_buffer_length);
    
    error_code = httpd_resp_send_chunk(req, frame_header, header_length);
    если (error_code != ESP_OK) перерыв;
    
    // Send frame data
    error_code = httpd_resp_send_chunk(req, (константа чар*)jpeg_buffer, jpeg_buffer_length);
    
    // Cleanup
    если (frame_buffer) {
      esp_camera_fb_return(frame_buffer);
      frame_buffer = NULL;
    } еще если (jpeg_buffer) {
      free(jpeg_buffer);
      jpeg_buffer = NULL;
    }
    
    если (error_code != ESP_OK) {
      Серийный номер.printf("Stream send error: %d\n", error_code);
      перерыв;
    }
    
    // Maintain target frame rate
    задерживать(1000 / FRAME_RATE);
    
    // Periodic status update
    если (frame_counter % 30 == 0) {
      без подписи длинный elapsed = (миллис() - stream_start_time) / 1000;
      Серийный номер.printf("Streaming: %lu frames over %lu seconds\n", frame_counter, elapsed);
    }
  }
  
  Серийный номер.println("Video stream ended");
  возвращаться error_code;
}

// ========== SERVER INITIALIZATION ==========
пустота initialize_video_streaming_server() {
  httpd_config_t server_config = HTTPD_DEFAULT_CONFIG();
  server_config.server_port = 80;
  server_config.ctrl_port = 32768;
  server_config.max_open_sockets = 3;
  server_config.backlog_conn = 2;
  
  httpd_uri_t stream_endpoint = {
    .uri = "/",
    .method = HTTP_GET,
    .handler = video_stream_handler,
    .user_ctx = NULL
  };
  
  httpd_uri_t stream_endpoint_alt = {
    .uri = "/stream",
    .method = HTTP_GET,
    .handler = video_stream_handler,
    .user_ctx = NULL
  };
  
  если (httpd_start(&camera_stream_server, &server_config) == ESP_OK) {
    httpd_register_uri_handler(camera_stream_server, &stream_endpoint);
    httpd_register_uri_handler(camera_stream_server, &stream_endpoint_alt);
    Серийный номер.printf("Streaming server started on port %d\n", server_config.server_port);
    Серийный номер.println("Access the stream at: http://[ESP32-IP]/ or http://[ESP32-IP]/stream");
  } еще {
    Серийный номер.println("Failed to start streaming server");
  }
}

// ========== CAMERA INITIALIZATION ==========
bool initialize_camera() {
  camera_config_t camera_config;
  
  camera_config.ledc_channel = LEDC_CHANNEL_0;
  camera_config.ledc_timer = LEDC_TIMER_0;
  camera_config.pin_d0 = Y2_GPIO_NUM;
  camera_config.pin_d1 = Y3_GPIO_NUM;
  camera_config.pin_d2 = Y4_GPIO_NUM;
  camera_config.pin_d3 = Y5_GPIO_NUM;
  camera_config.pin_d4 = Y6_GPIO_NUM;
  camera_config.pin_d5 = Y7_GPIO_NUM;
  camera_config.pin_d6 = Y8_GPIO_NUM;
  camera_config.pin_d7 = Y9_GPIO_NUM;
  camera_config.pin_xclk = XCLK_GPIO_NUM;
  camera_config.pin_pclk = PCLK_GPIO_NUM;
  camera_config.pin_vsync = VSYNC_GPIO_NUM;
  camera_config.pin_href = HREF_GPIO_NUM;
  camera_config.pin_sccb_sda = SIOD_GPIO_NUM;
  camera_config.pin_sccb_scl = SIOC_GPIO_NUM;
  camera_config.pin_pwdn = PWDN_GPIO_NUM;
  camera_config.pin_reset = RESET_GPIO_NUM;
  camera_config.xclk_freq_hz = 20000000;
  camera_config.pixel_format = PIXFORMAT_JPEG;
  
  // Adjust based on available PSRAM
  если (psramFound()) {
    Серийный номер.println("PSRAM detected - using higher quality settings");
    camera_config.frame_size = FRAME_SIZE;
    camera_config.jpeg_quality = JPEG_QUALITY;
    camera_config.fb_count = 2;
    camera_config.grab_mode = CAMERA_GRAB_LATEST;
  } еще {
    Серийный номер.println("No PSRAM detected - using reduced settings");
    camera_config.frame_size = FRAMESIZE_VGA;  // Reduced from SVGA
    camera_config.jpeg_quality = 15;           // Slightly lower quality
    camera_config.fb_count = 1;
  }
  
  esp_err_t camera_error = esp_camera_init(&camera_config);
  если (camera_error != ESP_OK) {
    Серийный номер.printf("Camera initialization failed with error 0x%x\n", camera_error);
    возвращаться ЛОЖЬ;
  }
  
  // Adjust additional camera settings
  sensor_t *camera_sensor = esp_camera_sensor_get();
  если (camera_sensor) {
    // Disable vertical flip and mirror
    camera_sensor->set_vflip(camera_sensor, 0);
    camera_sensor->set_hmirror(camera_sensor, 0);
    
    // Adjust saturation, brightness, contrast
    camera_sensor->set_saturation(camera_sensor, 0);
    camera_sensor->set_brightness(camera_sensor, 0);
    camera_sensor->set_contrast(camera_sensor, 0);
    
    // Apply special effects (0 = no effect)
    camera_sensor->set_special_effect(camera_sensor, 0);
    
    // White balance (0 = auto)
    camera_sensor->set_whitebal(camera_sensor, 1);
    
    // Automatic exposure control
    camera_sensor->set_exposure_ctrl(camera_sensor, 1);
    
    // Automatic gain control
    camera_sensor->set_gain_ctrl(camera_sensor, 1);
    
    Серийный номер.println("Camera sensor configured successfully");
  }
  
  возвращаться истинный;
}

// ========== MAIN SETUP FUNCTION ==========
пустота настраивать() {
  // Disable brownout detector for more stable operation
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
  
  Серийный номер.начинать(115200);
  Серийный номер.setDebugOutput(истинный);
  Серийный номер.println("\n\n========== ESP32-CAM Enhanced Streaming Server ==========");
  Серийный номер.println("Initializing...");
  
  // Initialize camera
  если (!initialize_camera()) {
    Серийный номер.println("Camera initialization failed! Restarting in 10 seconds...");
    задерживать(10000);
    ESP.restart();
  }
  Серийный номер.println("Camera initialized successfully");
  
  // Connect to WiFi
  Серийный номер.printf("Connecting to WiFi: %s\n", SSID);
  Wi-Fi.начинать(SSID, пароль);
  Wi-Fi.setSleep(ЛОЖЬ);  // Improve WiFi performance
  
  инт connection_attempts = 0;
  пока (Wi-Fi.статус() != WL_CONNECTED && connection_attempts < 30) {
    задерживать(500);
    Серийный номер.печать(".");
    connection_attempts++;
  }
  
  если (Wi-Fi.статус() != WL_CONNECTED) {
    Серийный номер.println("\nWiFi connection failed!");
    Серийный номер.println("Attempting to start access point mode...");
    
    // Fallback to AP mode if WiFi connection fails
    Wi-Fi.softAP("ESP32-CAM-AP", "password123");
    Серийный номер.печать("Access Point started. IP address: ");
    Серийный номер.println(Wi-Fi.softAPIP());
  } еще {
    Серийный номер.println("Wi-Fi успешно подключен!");
    Серийный номер.печать("IP address: ");
    Серийный номер.println(Wi-Fi.локальный IP());
    Серийный номер.печать("Signal strength (RSSI): ");
    Серийный номер.печать(Wi-Fi.RSSI());
    Серийный номер.println(" dBm");
  }
  
  // Start streaming server
  initialize_video_streaming_server();
  
  Серийный номер.println("========== System Ready ==========");
  Серийный номер.println("Stream available at:");
  Серийный номер.печать("  http://");
  Серийный номер.печать(Wi-Fi.локальный IP());
  Серийный номер.println("/");
  Серийный номер.печать("  http://");
  Серийный номер.печать(Wi-Fi.локальный IP());
  Серийный номер.println("/stream");
  Серийный номер.println("==================================");
}

// ========== MAIN LOOP ==========
пустота петля() {
  // Simple heartbeat indicator
  static без подписи длинный last_heartbeat = 0;
  если (миллис() - last_heartbeat > 30000) {
    Серийный номер.printf("System uptime: %lu seconds, Free heap: %u bytes\n", 
                  миллис() / 1000, ESP.getFreeHeap());
    last_heartbeat = миллис();
  }
  
  // Check WiFi connection periodically
  static без подписи длинный last_wifi_check = 0;
  если (миллис() - last_wifi_check > 60000) {
    если (Wi-Fi.статус() != WL_CONNECTED) {
      Серийный номер.println("WiFi connection lost. Attempting to reconnect...");
      Wi-Fi.reconnect();
    }
    last_wifi_check = миллис();
  }
  
  задерживать(100);
}

// Example: Adding a low-resolution stream
static esp_err_t low_res_stream_handler(httpd_req_t *req) {
  // Set camera to lower resolution temporarily
  sensor_t *s = esp_camera_sensor_get();
  инт current_framesize = s->статус.framesize;
  s->set_framesize(s, FRAMESIZE_QVGA); // 320x240
  
  // Handle stream (similar to main handler)
  
  // Restore original resolution
  s->set_framesize(s, current_framesize);
  возвращаться ESP_OK;
}

# configuration.yaml
camera:
  - платформа: generic
    name: "ESP32-CAM Front Door"
    still_image_url: http://[ESP32-IP]/capture
    stream_source: http://[ESP32-IP]/
    authentication: basic
    username: !secret esp32cam_username
    пароль: !secret esp32cam_password
    verify_ssl: ЛОЖЬ
    content_type: "multipart/x-mixed-replace;boundary=123456789000000000000987654321"
    frame_interval: 0.5
    limit_refetch_to_url_change: истинный

camera:
  - платформа: mjpeg
    name: "ESP32-CAM Backyard"
    mjpeg_url: http://[ESP32-IP]/
    username: !secret esp32cam_username
    пароль: !secret esp32cam_password
    authentication: basic

# Create an ESPHome configuration for ESP32-CAM
esphome:
  name: esp32-cam-front
  платформа: ESP32
  board: esp32-cam

wifi:
  SSID: !secret wifi_ssid
  пароль: !secret wifi_password
  manual_ip:
    static_ip: 192.168.1.100
    gateway: 192.168.1.1
    subnet: 255.255.255.0

camera:
  - платформа: esp32_camera
    name: "Front Door Camera"
    id: my_camera
    external_clock: истинный
    jpeg_quality: 12
    vertical_flip: истинный
    horizontal_mirror: истинный

    # Optional: Motion detection
    motion_detection:
      name: "Camera Motion"
      threshold: 0.5
      score: 0.8

    # Optional: Face detection
    face_detection:
      name: "Face Detected"

    # Optional: Save to SD card on event
    on_capture:
      затем:
        - camera.save_to_sd: my_camera
        - lambda: |-
            id(my_camera).take_image().perform();

automation:
  - alias: "Record on motion when away"
    trigger:
      платформа: состояние
      entity_id: binary_sensor.esp32_cam_motion
      к: ""на""
    condition:
      condition: состояние
      entity_id: device_tracker.person
      состояние: "not_home"
    action:
      - service: camera.record
        данные:
          entity_id: camera.esp32_cam_front
          filename: '/media/motion_{{ now().strftime("%Y%m%d_%H%M%S") }}.mp4'
          duration: 30

  - alias: "Snapshot on doorbell ring"
    trigger:
      платформа: состояние
      entity_id: binary_sensor.front_doorbell
      к: ""на""
    action:
      - service: camera.snapshot
        данные:
          entity_id: camera.esp32_cam_front
          filename: '/media/doorbell_{{ now().strftime("%Y%m%d_%H%M%S") }}.jpg'
      - service: notify.mobile_app
        данные:
          message: "Someone at the front door"
          данные:
            image: '/media/doorbell_{{ now().strftime("%Y%m%d_%H%M%S") }}.jpg'

// Simplified motion detection implementation
bool detect_motion(camera_fb_t* current_frame, camera_fb_t* previous_frame) {
  если (!current_frame || !previous_frame) возвращаться ЛОЖЬ;
  если (current_frame->width != previous_frame->width || 
      current_frame->height != previous_frame->height) {
    возвращаться ЛОЖЬ;
  }
  
  uint32_t diff_pixels = 0;
  uint32_t threshold = (current_frame->width * current_frame->height) / 100; // 1% of pixels
  
  // Compare frames (simplified - actual implementation would be more sophisticated)
  для (size_t i = 0; i < current_frame->len; i += 10) {
    если (abs(current_frame->buf[i] - previous_frame->buf[i]) > 30) {
      diff_pixels++;
      если (diff_pixels > threshold) {
        возвращаться истинный;
      }
    }
  }
  
  возвращаться ЛОЖЬ;
}

пустота capture_timelapse() {
  static без подписи длинный last_capture = 0;
  без подписи длинный interval = 30000; // Capture every 30 seconds
  
  если (миллис() - last_capture > interval) {
    camera_fb_t* fb = esp_camera_fb_get();
    если (fb) {
      // Save to SD card or send to server
      save_to_sd(fb, "/timelapse/image_" + Нить(миллис()) + ".jpg");
      esp_camera_fb_return(fb);
    }
    last_capture = миллис();
  }
}

#включать <ArduinoOTA.h>

пустота setupOTA() {
  ArduinoOTA.setHostname("esp32-cam");
  ArduinoOTA.setPassword("your_ota_password");
  
  ArduinoOTA.onStart([]() {
    Серийный номер.println("OTA update starting...");
  });
  
  ArduinoOTA.onEnd([]() {
    Серийный номер.println("\nOTA update complete!");
  });
  
  ArduinoOTA.onProgress([](без подписи инт progress, без подписи инт общий) {
    Серийный номер.printf("Progress: %u%%\r", (progress * 100) / общий);
  });
  
  ArduinoOTA.onError([](ota_error_t error) {
    Серийный номер.printf("Error[%u]: ", error);
  });
  
  ArduinoOTA.начинать();
}

// In loop(): ArduinoOTA.handle();