En el mundo actual, la tecnología ha avanzado tanto que ahora podemos tener nuestro propio servidor web de transmisión de video utilizando el ESP32-CAM. En este artículo, descubriremos cómo configurar este dispositivo para que funcione con Home Assistant, facilitando así la creación de un sistema de vigilancia personalizado y accesible desde cualquier lugar. ¡Sigue leyendo para aprender más sobre esta increíble tecnología!
En este proyecto, estamos construyendo una cámara de vigilancia IP utilizando la placa CAM ESP32. La cámara ESP32 alojará un servidor web de transmisión de vídeo al que podrá acceder desde cualquier dispositivo de su red.
Puede integrar este servidor web de transmisión de video con plataformas populares de automatización del hogar como asistente de hogar o Nudo-ROJO. En este tutorial te mostraremos cómo integrarlo con Home Assistant y Node-RED.
Mira el vídeotutorial
Puede ver el video tutorial o continuar leyendo esta página para obtener las instrucciones escritas.
Piezas requeridas
Para seguir este tutorial necesitarás los siguientes componentes:
- Cámara ESP32 con OV2640 – leer Las mejores placas de desarrollo CAM ESP32
- programador FTDI
- Cable puente hembra a hembra
- Cámara de seguridad tipo domo falsa/falsa
- Fuente de alimentación de 5V para ESP32-CAM
- Opcional – Home Assistant en Raspberry Pi:
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Presentamos el ESP32-CAM
El Leva ESP32 Es un módulo de cámara muy pequeño con el chip ESP32-S que cuesta menos de 10 dólares. Puede leer nuestra Guía de introducción a ESP32 CAM y aprender a utilizar el ejemplo de transmisión de vídeo y reconocimiento facial.
Servidor de transmisión de vídeo
Siga los siguientes pasos para crear un servidor web de transmisión de video usando ESP32 CAM al que puede acceder a través de su red local.
1. Instale el complemento ESP32
En este ejemplo, utilizamos Arduino IDE para programar la placa CAM ESP32. Por lo tanto, debe tener instalado Arduino IDE y el complemento ESP32. Siga uno de los siguientes tutoriales para instalar el complemento ESP32 si aún no lo ha hecho:
- Instalación de la placa ESP32 en Arduino IDE (Guía de Windows)
- Instalación de la Placa ESP32 en el IDE Arduino (Guía para Mac y Linux)
2. Código del servidor web de transmisión de video
A continuación, copie el siguiente código en su IDE de Arduino.
/*********
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-cam-video-streaming-web-server-camera-home-assistant/
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 to put your board in flashing mode
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*********/
#include "esp_camera.h"
#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h" //disable brownout problems
#include "esp_http_server.h"
//Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
#define PART_BOUNDARY "123456789000000000000987654321"
// This project was tested with the AI Thinker Model, M5STACK PSRAM Model and M5STACK WITHOUT PSRAM
#define CAMERA_MODEL_AI_THINKER
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WITHOUT_PSRAM
// Not tested with this model
//#define CAMERA_MODEL_WROVER_KIT
#if defined(CAMERA_MODEL_WROVER_KIT)
#define PWDN_GPIO_NUM -1
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 21
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27
#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 19
#define Y4_GPIO_NUM 18
#define Y3_GPIO_NUM 5
#define Y2_GPIO_NUM 4
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22
#elif defined(CAMERA_MODEL_M5STACK_PSRAM)
#define PWDN_GPIO_NUM -1
#define RESET_GPIO_NUM 15
#define XCLK_GPIO_NUM 27
#define SIOD_GPIO_NUM 25
#define SIOC_GPIO_NUM 23
#define Y9_GPIO_NUM 19
#define Y8_GPIO_NUM 36
#define Y7_GPIO_NUM 18
#define Y6_GPIO_NUM 39
#define Y5_GPIO_NUM 5
#define Y4_GPIO_NUM 34
#define Y3_GPIO_NUM 35
#define Y2_GPIO_NUM 32
#define VSYNC_GPIO_NUM 22
#define HREF_GPIO_NUM 26
#define PCLK_GPIO_NUM 21
#elif defined(CAMERA_MODEL_M5STACK_WITHOUT_PSRAM)
#define PWDN_GPIO_NUM -1
#define RESET_GPIO_NUM 15
#define XCLK_GPIO_NUM 27
#define SIOD_GPIO_NUM 25
#define SIOC_GPIO_NUM 23
#define Y9_GPIO_NUM 19
#define Y8_GPIO_NUM 36
#define Y7_GPIO_NUM 18
#define Y6_GPIO_NUM 39
#define Y5_GPIO_NUM 5
#define Y4_GPIO_NUM 34
#define Y3_GPIO_NUM 35
#define Y2_GPIO_NUM 17
#define VSYNC_GPIO_NUM 22
#define HREF_GPIO_NUM 26
#define PCLK_GPIO_NUM 21
#elif defined(CAMERA_MODEL_AI_THINKER)
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27
#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22
#else
#error "Camera model not selected"
#endif
static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "rn--" PART_BOUNDARY "rn";
static const char* _STREAM_PART = "Content-Type: image/jpegrnContent-Length: %urnrn";
httpd_handle_t stream_httpd = NULL;
static esp_err_t stream_handler(httpd_req_t *req){
camera_fb_t * fb = NULL;
esp_err_t res = ESP_OK;
size_t _jpg_buf_len = 0;
uint8_t * _jpg_buf = NULL;
char * part_buf[64];
res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
if(res != ESP_OK){
return res;
}
while(true){
fb = esp_camera_fb_get();
if (!fb) {
Serial.println("Camera capture failed");
res = ESP_FAIL;
} else {
if(fb->width > 400){
if(fb->format != PIXFORMAT_JPEG){
bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
esp_camera_fb_return(fb);
fb = NULL;
if(!jpeg_converted){
Serial.println("JPEG compression failed");
res = ESP_FAIL;
}
} else {
_jpg_buf_len = fb->len;
_jpg_buf = fb->buf;
}
}
}
if(res == ESP_OK){
size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
}
if(res == ESP_OK){
res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
}
if(res == ESP_OK){
res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
}
if(fb){
esp_camera_fb_return(fb);
fb = NULL;
_jpg_buf = NULL;
} else if(_jpg_buf){
free(_jpg_buf);
_jpg_buf = NULL;
}
if(res != ESP_OK){
break;
}
//Serial.printf("MJPG: %uBn",(uint32_t)(_jpg_buf_len));
}
return res;
}
void startCameraServer(){
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
config.server_port = 80;
httpd_uri_t index_uri = {
.uri = "/",
.method = HTTP_GET,
.handler = stream_handler,
.user_ctx = NULL
};
//Serial.printf("Starting web server on port: '%d'n", config.server_port);
if (httpd_start(&stream_httpd, &config) == ESP_OK) {
httpd_register_uri_handler(stream_httpd, &index_uri);
}
}
void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
Serial.begin(115200);
Serial.setDebugOutput(false);
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;
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;
}
// 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;
}
// Wi-Fi connection
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.print("Camera Stream Ready! Go to: http://");
Serial.print(WiFi.localIP());
// Start streaming web server
startCameraServer();
}
void loop() {
delay(1);
}
Antes de cargar el código, debe agregar sus credenciales de red a las siguientes variables:
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";Luego asegúrese de seleccionar el módulo de cámara correcto. En este caso utilizamos el modelo AI-THINKER.
Si usa el mismo módulo de cámara, no necesita cambiar el código.
#define CAMERA_MODEL_AI_THINKERAhora puedes cargar el código en tu placa CAM ESP32.
3. Sube el código
Conecte la placa CAM ESP32 a través de un programador FTDI. Siga el siguiente diagrama esquemático:
Muchos programadores FTDI tienen un puente que le permite seleccionar 3,3 V o 5 V. Asegúrese de que el puente esté en el lugar correcto para seleccionar 5V.
Importante: GPIO 0 debe estar conectado a Dimensiones para que puedas subir el código.
| Leva ESP32 | programador FTDI |
| Dimensiones | Dimensiones |
| 5V | VCC (5V) |
| U0R | Texas |
| U0T | RX |
| GPIO 0 | Dimensiones |
Para cargar el código, siga los siguientes pasos:
1) Ir a Herramientas > tablón y elige Pensador de IA ESP32-CAM.
2) Ir a Herramientas > Puerto y seleccione el puerto COM al que está conectado el ESP32.
3) Luego haga clic en el botón «Cargar» para cargar el código.
4) Cuando vea estos puntos en la ventana de depuración como se muestra a continuación, presione el botón RST incorporado del ESP32-CAM.
Después de unos segundos, el código debería cargarse correctamente en su tablero.
Obtener la dirección IP
Después de cargar el código, desconecta GPIO 0 fuera de Dimensiones. Abra el monitor en serie con una velocidad de baudios de 115200. Presione el botón de reinicio incorporado del ESP32-CAM.
La dirección IP del ESP32 debe estar impresa en el monitor serie.
Acceso al servidor de streaming de vídeo.
Ahora puede acceder al servidor de transmisión de su cámara en su red local. Abra un navegador e ingrese la dirección IP del ESP32-CAM. Debería cargarse una página con la transmisión de video actual.
Integración del asistente doméstico
Para la mayoría de las personas puede resultar útil simplemente ejecutar ESP32 CAM a través de IP, pero también puede integrar este proyecto con Home Assistant (u otras plataformas de automatización del hogar). Continúe leyendo para aprender cómo integrarse con Home Assistant.
requisitos
- Deberías estar familiarizado con Raspberry Pi; lee Introducción a Raspberry Pi.
- Comenzando con Home Assistant en Raspberry Pi
Agregue ESP32-CAM a Home Assistant
Abre el panel de Home Assistant y ve a más Ajustes Menú.
Abierto Configurar la interfaz de usuario:
Agregue una nueva tarjeta a su panel de control:
Elige una tarjeta de tipo Imagen.
En el Campo URL de imageningrese su dirección IP de ESP32 CAM. Luego haga clic en “AHORRAR“ y regrese al tablero principal.
Si utiliza el archivo de configuración, debe agregar lo siguiente.
Después de eso, Home Assistant puede mostrar la transmisión de video ESP32-CAM.
Un paso mas alla
Para llevar este proyecto más lejos, puedes usar uno cámara ficticia falsa y coloque el ESP32-CAM en él.
La placa ESP32 CAM encaja perfectamente en la carcasa de la cámara ficticia.
Puedes alimentarlo con una fuente de alimentación de 5V a través del ESP32-CAM Dimensiones Y 5V Lápices.
Coloque la cámara de seguridad en un lugar adecuado.
A continuación, vaya a la dirección IP de la cámara o al panel de Home Assistant y vea lo que sucede en tiempo real. La siguiente imagen nos muestra probando la cámara de transmisión de video. Sara toma una captura de pantalla mientras yo filmo con la cámara.
Es impresionante lo que este pequeño $9 módulo de cámara ESP32 Puede y funciona de forma fiable. Ahora podemos usar la cámara de vigilancia para ver lo que sucede en la puerta de mi casa en tiempo real.
Consejo: integración Node-RED
El servidor web de transmisión de video también se integra con Node-RED y Node-RED Dashboard. Todo lo que necesitas hacer es crear un nodo de plantilla y agregar lo siguiente:
<div style="margin-bottom: 10px;">
<img src="https://YOUR-ESP32-CAM-IP-ADDRESS" width="650px">
</div>En el fuente Atributo que necesita para ingresar su dirección IP ESP32-CAM:
<div style="margin-bottom: 10px;">
<img src="https://192.168.1.91" width="650px">
</div>Solución de problemas
Si recibe alguno de los siguientes errores, consulte nuestra Guía de solución de problemas de ESP32-CAM: solución de los problemas más comunes
- No se pudo conectar a ESP32: tiempo de espera de espera para el encabezado del paquete
- La inicialización de la cámara falló con el error 0x20001 o similar
- Detector de caída de tensión o error de meditación del gurú
- Error de boceto demasiado grande: se seleccionó un esquema de partición incorrecto
- La tarjeta en COMX no está disponible – Puerto COM no seleccionado
- Error de Psram: el servicio GPIO ISR no está instalado
- Señal WiFi débil
- No hay dirección IP en el monitor serie Arduino IDE
- No se puede abrir el servidor web
- La imagen está retrasada/muestra una latencia alta.
[eBook] Crea proyectos CAM ESP32 con Arduino IDE
Aprenda a programar y crear proyectos con ESP32-CAM usando Arduino IDE 17 DESCARGAR «
Aprenda a programar y crear proyectos con ESP32-CAM usando Arduino IDE 17 DESCARGAR «
Envolver
En este tutorial, le mostramos cómo crear un servidor web de transmisión de video simple para construir una cámara IP usando la placa CAM ESP32. El servidor web que creamos se puede integrar fácilmente en tu plataforma domótica como Node-RED o Home Assistant.
Esperamos que este tutorial le resulte útil. Si aún no tienes una CAM ESP32, puedes tómalo aquí.
Si te gusta este proyecto, es posible que también te gusten otros proyectos que utilizan ESP32-CAM:
- Streaming de vídeo ESP32 CAM y reconocimiento facial con Arduino IDE
- ESP32-CAM Tomar foto y guardar en tarjeta MicroSD
- ESP32-CAM Detector de movimiento PIR con grabación de fotografías (guarda en tarjeta microSD)
- ESP32-CAM toma fotografías y las muestra en el servidor web
- Crear proyectos ESP32-CAM (libro electrónico)
- Lea todos nuestros proyectos, tutoriales y guías de ESP32 CAM
¡Gracias por leer!
Servidor web de transmisión de video ESP32-CAM (funciona con Home Assistant)
En este proyecto, vamos a construir una cámara de vigilancia IP con la placa ESP32-CAM. La cámara ESP32 va a hospedar un servidor web de transmisión de video al que puedes acceder con cualquier dispositivo en tu red.
¿Qué necesitas para este proyecto?
Para seguir este tutorial, necesitarás los siguientes componentes:
- ESP32-CAM con OV2640
- Programador FTDI
- Cables jumper hembra a hembra
- Cámara de seguridad falsa/dummy
- Alimentación de 5V para ESP32-CAM
Opcionalmente, si deseas utilizar Home Assistant en un Raspberry Pi, necesitarás:
- Placa Raspberry Pi
- Tarjeta MicroSD de 32GB Clase 10
- Alimentación para Raspberry Pi (5V 2.5A)
Introducción a la ESP32-CAM
La ESP32-CAM es un módulo de cámara muy pequeño con el chip ESP32-S que cuesta menos de $10. Puedes encontrar toda la información precisar sobre la ESP32-CAM en nuestra guía de inicio.
Configuración del servidor de transmisión de video
Sigue los siguientes pasos para construir un servidor web de transmisión de video con la ESP32-CAM:
- Instala el complemento ESP32
- Copia el código del servidor web de transmisión de video en Arduino IDE
- Sube el código a tu ESP32-CAM
Antes de subir el código, asegúrate de insertar tus credenciales de red en las variables correspondientes.
const char* ssid = "REEMPLAZAR_CON_TU_SSID"; const char* password = "REEMPLAZAR_CON_TU_CONTRASEÑA";
Luego, selecciona el modelo de cámara correcto en el código. En este caso, estamos utilizando el modelo AI-THINKER.
#define CAMERA_MODEL_AI_THINKER
Luego, puedes subir el código a tu placa ESP32-CAM.
Integración con Home Assistant
Puedes integrar este servidor de video con Home Assistant para una vigilancia más avanzada. Sigue los pasos de configuración en Home Assistant para agregar la cámara ESP32-CAM a tu panel de control.
Además, puedes llevar este proyecto más allá colocando la ESP32-CAM dentro de una cámara de seguridad falsa y alimentándola con un adaptador de 5V. Esto te permitirá ver en tiempo real lo que sucede en tu hogar a través de la cámara.
Para integrar el servidor de video con Node-RED, simplemente crea un nodo de Plantilla y agrega la dirección IP de la ESP32-CAM en el código HTML.
Si encuentras algún problema durante el proceso, consulta nuestra Guía de Resolución de Problemas de la ESP32-CAM para soluciones.
¡Esperamos que este tutorial te haya sido útil para construir tu propio servidor de transmisión de video con la ESP32-CAM integrado con Home Assistant y Node-RED!
Qué genial que se pueda usar la ESP32-CAM como servidor de video con Home Assistant. ¡Voy a intentarlo también, gracias por la idea!
¡Increíble lo que se puede hacer con un ESP32-CAM! Definitivamente voy a probar esto en mi casa. ¡Gracias por compartir!
¡Me parece súper interesante la idea de usar un ESP32-CAM como servidor de video con Home Assistant! Definitivamente voy a probarlo en mi hogar, ¡gracias por la recomendación!