esp32cam推流至服务器+网站显示

已于 2024-04-25 10:20:25 修改
阅读量893 收藏 25
点赞数 7
文章标签： 服务器 物联网
于 2024-04-25 10:15:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34172132/article/details/138175674
版权

文章目录

概要

记录一次esp32cam 推流到公网的学习，本来是想找rstp跟rmtp推流能力不足放弃了，最后采用了图传的方式上传。

这里记录一下自己学习的几种方式，以免忘记

1.esp32cam+nodejs+python（tcp）

esp32 cam 的代码：
这里是将esp32拍摄的图片流一张一张的上传到tcp服务器中。

/*
网络调试助手
https://soft.3dmgame.com/down/213757.html
*/
#include <Arduino.h>
#include <WiFi.h>
#include "esp_camera.h"
#include <vector>
 
const char *ssid = "*******";//wifi名称
const char *password = "--------------";//wifi密码
const IPAddress serverIP(192,168,0,2); //欲访问的地址
uint16_t serverPort = 8080;         //服务器端口号
 
#define maxcache 1430
 
WiFiClient client; //声明一个客户端对象，用于与服务器进行连接
 
//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
 
static camera_config_t camera_config = {
    .pin_pwdn = PWDN_GPIO_NUM,
    .pin_reset = RESET_GPIO_NUM,
    .pin_xclk = XCLK_GPIO_NUM,
    .pin_sscb_sda = SIOD_GPIO_NUM,
    .pin_sscb_scl = SIOC_GPIO_NUM,
    
    .pin_d7 = Y9_GPIO_NUM,
    .pin_d6 = Y8_GPIO_NUM,
    .pin_d5 = Y7_GPIO_NUM,
    .pin_d4 = Y6_GPIO_NUM,
    .pin_d3 = Y5_GPIO_NUM,
    .pin_d2 = Y4_GPIO_NUM,
    .pin_d1 = Y3_GPIO_NUM,
    .pin_d0 = Y2_GPIO_NUM,
    .pin_vsync = VSYNC_GPIO_NUM,
    .pin_href = HREF_GPIO_NUM,
    .pin_pclk = PCLK_GPIO_NUM,
    
    .xclk_freq_hz = 20000000,
    .ledc_timer = LEDC_TIMER_0,
    .ledc_channel = LEDC_CHANNEL_0,
    
    .pixel_format = PIXFORMAT_JPEG,
    .frame_size = FRAMESIZE_VGA,
    .jpeg_quality = 12,
    .fb_count = 1,
};
void wifi_init()
{
    WiFi.mode(WIFI_STA);
    WiFi.setSleep(false); //关闭STA模式下wifi休眠，提高响应速度
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(500);
        Serial.print(".");
    }
    Serial.println("WiFi Connected!");
    Serial.print("IP Address:");
    Serial.println(WiFi.localIP());
}
esp_err_t camera_init() {
    //initialize the camera
    esp_err_t err = esp_camera_init(&camera_config);
    if (err != ESP_OK) {
        Serial.println("Camera Init Failed");
        return err;
    }
    sensor_t * s = esp_camera_sensor_get();
    //initial sensors are flipped vertically and colors are a bit saturated
    if (s->id.PID == OV2640_PID) {
    //        s->set_vflip(s, 1);//flip it back
    //        s->set_brightness(s, 1);//up the blightness just a bit
    //        s->set_contrast(s, 1);
    }
    Serial.println("Camera Init OK!");
    return ESP_OK;
}
 
void setup()
{
    Serial.begin(115200);
    wifi_init();
    camera_init();
}
 
void loop()
{
    Serial.println("Try To Connect TCP Server!");
    if (client.connect(serverIP, serverPort)) //尝试访问目标地址
    {
        Serial.println("Connect Tcp Server Success!");
        //client.println("Frame Begin");  //46 72 61 6D 65 20 42 65 67 69 6E // 0D 0A 代表换行  //向服务器发送数据
        while (1){       
          camera_fb_t * fb = esp_camera_fb_get();
          uint8_t * temp = fb->buf; //这个是为了保存一个地址，在摄像头数据发送完毕后需要返回，否则会出现板子发送一段时间后自动重启，不断重复
          if (!fb)
          {
              Serial.println( "Camera Capture Failed");
          }
          else
          { 
            //先发送Frame Begin 表示开始发送图片 然后将图片数据分包发送 每次发送1430 余数最后发送 
            //完毕后发送结束标志 Frame Over 表示一张图片发送完毕 
            client.print("Frame Begin"); //一张图片的起始标志
            // 将图片数据分段发送
            int leng = fb->len;
            int timess = leng/maxcache;
            int extra = leng%maxcache;
            for(int j = 0;j< timess;j++)
            {
              client.write(fb->buf, maxcache); 
              for(int i =0;i< maxcache;i++)
              {
                fb->buf++;
              }
            }
            client.write(fb->buf, extra);
            client.print("Frame Over");      // 一张图片的结束标志
            Serial.print("This Frame Length:");
            Serial.print(fb->len);
            Serial.println(".Succes To Send Image For TCP!");
            //return the frame buffer back to the driver for reuse
            fb->buf = temp; //将当时保存的指针重新返还
            esp_camera_fb_return(fb);  //这一步在发送完毕后要执行，具体作用还未可知。        
          }
          delay(20);//短暂延时 增加数据传输可靠性
        }
        /*
        while (client.connected() || client.available()) //如果已连接或有收到的未读取的数据
        {
            if (client.available()) //如果有数据可读取
            {
                String line = client.readStringUntil('\n'); //读取数据到换行符
                Serial.print("ReceiveData：");
                Serial.println(line);
                client.print("--From ESP32--:Hello Server!");    
            }
        }
        Serial.println("close connect!");
        client.stop(); //关闭客户端
        */
    }
    else
    {
        Serial.println("Connect To Tcp Server Failed!After 10 Seconds Try Again!");
        client.stop(); //关闭客户端
    }
    delay(10000);
}

以下是nodejs搭建tcp服务器的代码：

因为自己没用过nodejs服务器，当时弄这个花了不时间。这里同时记录下nodejs服务器的简单搭建。这里用的是宝塔搭建的：
在这里插入图片描述

在这里插入图片描述
以上nodejs的简单搭建就算完成。

如果想在本地启动，启动方式是：

node app.js

// 创建tcp连接服务
const net = require('net')
const { size } = require('underscore')
const HOST = '192.168.0.2'
const PORT = 8080
 

// 统计连接客户端的个数
var count = 0
 
// 创建slave_server服务
const slave_server = new net.createServer()
// slave_server.setEncoding = 'UTF-8'
 
// 保存监视器的socket
var s
 
// 获得一个连接，该链接自动关联scoket对象
var tcp_sock = null
slave_server.on('connection', sock => {
  tcp_sock = sock
  sock.name = ++count
  console.log(`当前连接客户端数：${count}`)
 
  // 接收client发来的信息  
  sock.on('data', data => {
    // console.log(`客户端${sock.name}发来一个信息：${data}`)
 
    // 判断是否为监视器发来的链接
    if (data == 'monitor') {
      
      // 则把当前的socket保存起来
      s = sock
    } else {
      s.write(data)
    }
  })
 
  // 为socket添加error事件处理函数
  sock.on('error', error => { //监听客户端异常
    console.log('error' + error)
    sock.end()
  })
 
  // 服务器关闭时触发，如果存在连接，这个事件不会被触发，直到所有的连接关闭
  sock.on('close', () => {
    console.log(`客户端${sock.name}下线了`)
    count -= 1
  })
})
 
// listen函数开始监听指定端口
slave_server.listen(PORT, () => {
  console.log(`服务器已启动，运行在：http://xxxx:xxxx`)
})

python客户端：
这边是在windows上启动的

python app.py

import socket
import threading
import time
import numpy as np
import cv2
import subprocess
from moviepy.editor import *
 
begin_data = b'Frame Begin'
end_data = b'Frame Over'

#接收数据
# ESP32发送一张照片的流程
# 先发送Frame Begin 表示开始发送图片 然后将图片数据分包发送 每次发送1430 余数最后发送
# 完毕后发送结束标志 Frame Over 表示一张图片发送完毕
# 1430 来自ESP32cam发送的一个包大小为1430 接收到数据 data格式为b''
def handle_sock(sock, addr):
    temp_data = b''
    t1 = int(round(time.time() * 1000))
    
    while True:
        data = sock.recv(1430)
        # 如果这一帧数据包的开头是 b'Frame Begin' 则是一张图片的开始
        if data[0:len(begin_data)] == begin_data:
            # 将这一帧数据包的开始标志信息（b'Frame Begin'）清除   因为他不属于图片数据
            data = data[len(begin_data):len(data)]
            # 判断这一帧数据流是不是最后一个帧 最后一针数据的结尾时b'Frame Over'
            while data[-len(end_data):] != end_data:
                temp_data = temp_data + data  # 不是结束的包 讲数据添加进temp_data
                data = sock.recv(1430)# 继续接受数据 直到接受的数据包包含b'Frame Over' 表示是这张图片的最后一针
            # 判断为最后一个包 将数据去除 结束标志信息 b'Frame Over'
            temp_data = temp_data + data[0:(len(data) - len(end_data))]  # 将多余的（\r\nFrame Over）去掉 其他放入temp_data
            # 显示图片
            receive_data = np.frombuffer(temp_data, dtype='uint8')  # 将获取到的字符流数据转换成1维数组
            r_img = cv2.imdecode(receive_data, cv2.IMREAD_COLOR)  # 将数组解码成图像
            r_img = r_img.reshape(480, 640, 3)
            t2 = int(round(time.time() * 1000))
            fps = 1000//(t2-t1)
            cv2.putText(r_img, "FPS" + str(fps), (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
            cv2.imshow('server_frame', r_img)

            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

            t1 = t2
            print("接收到的数据包大小：" + str(len(temp_data)))  # 显示该张照片数据大小
            temp_data = b''  # 清空数据 便于下一章照片使用
 
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.connect(("192,168,0,2", 8080))
server.send('monitor'.encode("utf-8"))
 
#主线程循环接收客户端连接
handle_sock(server, '')

全部代码就这些，主要的流程是：
esp32上传到nodejs服务器->nodejs服务器接收转发->python客户端请求服务器，服务器下发

但是这里的python客户端必须用在windows，因为python的cv2.imshow是具有图像界面的，用在服务器上会报错（反正我用的时候会报错，有更好的办法可以告诉我）

以上代码出处：
链接: https://blog.csdn.net/phoenix3k/article/details/128446232

这里的服务端也可以直接使用python+ffmpeg转发成视频流，但是我实现不了，技术不够。能解决的朋友麻烦踢下我。

因为我的业务是想要直接能在公网上播放的，所以上面的方案我的技术实现不了，所以我采用了planB。

2.esp32cam+python+vue（websocket）

esp32cam:

#include "WiFi.h"
#include "esp_camera.h"
//#include "base64.h"

#include <ArduinoJson.h>
#include <WebSocketsClient.h>
//#include <SocketIOclient.h>

// Pin definition for 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


// Replace with your network credentials
const char* hostname = "ESP32CAM";
const char* ssid = "Tenda_66A6B0";
const char* password = "12345678";
WebSocketsClient webSocket;

void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {

  switch(type) {
    case WStype_DISCONNECTED:
      Serial.printf("[WSc] Disconnected!\n");
      break;
    case WStype_CONNECTED: {
      Serial.printf("[WSc] Connected to url: %s\n", payload);
      //webSocket.sendTXT("camlogin");
    }
      break;
    case WStype_TEXT:
      Serial.printf("[WSc] get text: %s\n", payload);
      break;
    case WStype_BIN:
//      Serial.printf("[WSc] get binary length: %u\n", length);
      break;
    case WStype_PING:
        // pong will be send automatically
        Serial.printf("[WSc] get ping\n");
        break;
    case WStype_PONG:
        // answer to a ping we send
        Serial.printf("[WSc] get pong\n");
        break;
    }

}

void setupCamera()
{

    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;
    
    config.frame_size = FRAMESIZE_QVGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10;
    config.fb_count = 1;
  
    // Init Camera
    esp_err_t err = esp_camera_init(&config);
    if (err != ESP_OK) {
      Serial.printf("Camera init failed with error 0x%x", err);
      return;
    }
}

void setup(){
  Serial.begin(115200);
  
  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi..");
  }

  // Print ESP32 Local IP Address
  Serial.println(WiFi.localIP());

  setupCamera();
  
  // server address, port and URL
  webSocket.begin("192,168,0,2",8080);
  webSocket.onEvent(webSocketEvent);
  webSocket.setReconnectInterval(5000);
  webSocket.enableHeartbeat(15000, 3000, 2); 
}

unsigned long messageTimestamp = 0;
void loop() {
    webSocket.loop();
    uint64_t now = millis();

    if(now - messageTimestamp > 10) {
        messageTimestamp = now;

        camera_fb_t * fb = NULL;

        // Take Picture with Camera
        fb = esp_camera_fb_get();  
        if(!fb) {
          Serial.println("Camera capture failed");
          return;
        }
        webSocket.sendBIN(fb->buf,fb->len);
        Serial.println("Image sent");
        esp_camera_fb_return(fb); 
    }
}

python服务器：

如果要多人查看可以在代码中吧注释打开，然后吧await USERS[len(USERS)-1].send(data)注释，但是这里会报code = 1001 (going away),暂时解决不了,希望有缘人可以告知

if len(USERS) >= 2:
	await USERS[len(USERS)-1].send(data)
    #for USER in USERS:
    	# await USER.send(data)

import asyncio
import websockets
import cv2 as cv
import binascii
import time
import numpy as np
USERS = []

async def recv_msg(websocket):
    
    USERS.append(websocket)
    print('user',USERS,len(USERS))
    while True:
        try:
            recv_text = await websocket.recv()

            data = binascii.a2b_hex(recv_text.hex())
            data1 = np.frombuffer(data, dtype=np.uint8)
            lenmes=len(data)
            if lenmes < 1000:
                continue
            img = cv.imdecode(data1, 1)
            #cv.imshow('result', img)
            cv.waitKey(1)
            if len(USERS) >= 2:
                await USERS[len(USERS)-1].send(data)
                #for USER in USERS:
                    # await USER.send(data)
                    # asyncio.ensure_future(USER.send(data))
                    #time.sleep(0.01)
            data = ''
        finally:
            pass
async def main_logic(websocket, path):
    await recv_msg(websocket)

# 把ip换成自己本地的ip
start_server = websockets.serve(main_logic, "",8080)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

前端vue展示：

esp.vue

<template>
  <div>
    <img id="show" style="width:300px;" />
  </div>
</template>
<script src="./esp.js"></script>

esp.js

/* eslint-disable */

export default {
    components: {
    },
    data() {
        return {
            url: "",
            websocket: null
        }
    },
    mounted() {

        this.initWebSocket();
    },
    created() {
    },
    methods: {
        initWebSocket() {
            var that = this
            var wsUri = "ws://192.168.0.2:8080/";
            this.websocket = new WebSocket(wsUri);
            this.websocket.onopen = function (evt) {
                that.onOpen(evt)
            };
            this.websocket.onclose = function (evt) {
                that.onClose(evt)
            };
            this.websocket.onmessage = function (evt) {
                that.onMessage(evt)
            };
            this.websocket.onerror = function (evt) {
                that.onError(evt)
            };
        },
        onOpen(evt) {
            console.log("CONNECTED")
        },
        onClose(evt) {
            console.log("DISCONNECTED")
        },
        onMessage(evt) {
            var reader = new FileReader();

            reader.onload = function (eve) {
                if (eve.target.readyState == FileReader.DONE) {
                    var img = document.getElementById("show");
                    img.src = this.result;
                }
            };
            reader.readAsDataURL(event.data);
        },
        onError(evt) {
            console.log(evt.data)
        }
    }
}

以上就可以在网页前段查看视频。
主要流程是：
esp32cam上传 图片帧到服务器上->python接收图片下发->vue展示
以上代码出处：
链接: https://github.com/jeiry/esp32cam-and-mp

小结

esp32cam 摄像头分辨率修改：
config.frame_size
FRAMESIZE_UXGA (1600 x 1200)
FRAMESIZE_QVGA (320 x 240)
FRAMESIZE_CIF (352 x 288)
FRAMESIZE_VGA (640 x 480)
FRAMESIZE_SVGA (800 x 600)
FRAMESIZE_XGA (1024 x 768)
FRAMESIZE_SXGA (1280 x 1024)

像素格式：
config.pixel_format
PIXFORMAT_RGB565
PIXFORMAT_YUV422
PIXFORMAT_GRAYSCALE
PIXFORMAT_JPEG

结语：
这里只是提供一下例子，有更好的方法希望可以告知一下。大家一起相互学习

______young
关注
  • 7
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
ESP32-CAM-RTSP：使用AI Thinker ESP32 CAM进行VLC实时流和录制
02-23
ESP32-CAM-RTSP 使用AI Thinker ESP32 CAM进行VLC实时流式传输和记录。 VLC RTSP网络流的说明： rtsp：//192.168.1.10：554 / mjpeg / 1
ESP32-CAM网络摄像头系列-01-基于RTSP协议的局域网视频推流/拉流的简单实现
YANGJIERUN的博客
02-24 5794
【代码】基于RTSP协议的局域网视频拉流代码-Python3+Opencv实现。
ESP32_CAM使用HTTP推流图像到本地服务器，附Arduino IDE+VsCode 环境搭建
cgy233的博客
06-04 4691
使用ESP32-S CAM 开发板进行开发，通过驱动摄像头，将采集的图像通过HTTP推流到本地服务器，访问WEB后台即可查看实时画面，包含人脸检测、人脸识别功能，使用Arduino IDE进行实现, 因为个人习惯，顺便在VsCode上配置了Arduino平台的开发环境。...............
ESP32-CAM初始篇：Arduino环境搭建--＞实现局域网推流
哒宰的博客
11-27 9862
esp32-sam之Arduino开发环境搭建
基于开源的Micro-RTSP，使用VLC和ffmpeg拉流播放RTSP视频流，本例使用安信可ESP32 CAM进行推流。
katerdaisy的博客
12-13 3080
基于开源的Micro-RTSP，使用VLC和ffmpeg拉流播放RTSP视频流，本例使用安信可ESP32 CAM进行推流。 vlc播放命令为：rtsp://192.168.43.128:8554/mjpeg/1。 ffmpeg播放命令为：ffplay rtsp://192.168.43.128:8554/mjpeg/1。
Arduino IDE + Esp32 Cam + 实现视频流 + 开发环境部署
10-22
Arduino IDE + Esp32 Cam + 实现视频流 + 开发环境部署
esp32-cam-mjpeg-multiclient:ESP32 MJPEG多客户端流媒体服务器
04-23
ESP32 MJPEG多客户端流媒体服务器这是为AI-Thinker ESP32-CAM或ESP-EYE模块实现的简单MJPEG流网络服务器。 经过测试，可以与VLC和Blynk视频小部件一起使用。 此版本使用FreeRTOS任务来启用流传输，最多可连接10个...
stm32+esp8266连web服务器
06-01
stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+...
69028+ESP32-CAM摄像头开发板+WiFi+蓝牙模块ESP32串口转WiFi物联网.zip
01-08
69028+ESP32-CAM摄像头开发板+WiFi+蓝牙模块ESP32串口转WiFi物联网.zip
esp32-cam拍照并显示在tft
11-29
tft实时显示esp32-cam拍照的图片，右下角显示帧数。屏幕采用2 2 tft spi 320x240。
ESP32-CAM视频传输至公网服务器并转发视频数据流
phoenix3k的博客
12-26 7621
再次特别说明一下, 先启动服务器端代码, 然后在电脑端运行python端代码, 最后再烧录esp32-cam的代码. 我在服务器端的逻辑是接收到'monitor'字符串时认为是客户端监视器, 把对应的socket保存一下, 然后当接收到下一个socket连接时, 则默认认为是esp32-cam, 将之前保存的socket取出来, 把视频流数据转发出去, 此种方式只能有一个esp32-cam和一个客户端监视器, 有需要的小伙伴可以自行修改代码.首先声明下esp32-cam和电脑客户端的代码都是参考了。
ESP32-CAM 摄像头开发板 进行 推流 已解决
PHP代码的博客
04-05 3191
项目背景，自己喜欢折腾电子。对嘉立创打板子。非常热爱。 购买了n多个电子模块 都在这儿进行一一展示， 配置参数 祖传代码 #include "esp_camera.h" #include <WiFi.h> // // WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality // Ensure ESP32 Wrover Module or othe...
再谈ESP32_CAM视频传输至公网服务器
最新发布
phoenix3k的博客
04-28 288
很久没写文章了，最近闲来无事，又研究了下关于esp32_cam，之前也写过一篇文章，讲述了如何把视频流推送至公网服务器，但是用到的代码很不统一，esp32_cam端用的是c语言，服务器用的是nodejs，拉流客户端用的是python，看上去很别扭，更重要的是，虽然能推流至服务器，但传输效果也不是很理想，于是把三端的代码统一成了python，话不多说，直接上代码。此处要修改的是端口号，要跟esp32_cam中自定义的端口号一致，其它的看注释即可。此处要修改的是公网ip和自定义的端口号。
基于ESP32-CAM的RSTP协议网络摄像头
xitianqu的博客
12-16 3469
本次介绍的程序是使用ESP32-CAM进行图像采集并将图像以RTSP协议进行无线传输。在同网络的PC上使用软件对摄像头的图像进行拉取观看。
如何使用ESP32相机模组实现视频流和人脸识别
佐佐沐
07-29 4081
AI-ThinkerESP32-CAM模块配有一颗ESP32-S芯片、超小尺寸的OV2640相机和MicroSD卡插槽。MicroSD卡插槽可用于存储从相机拍摄的图像或存储文件。该ESP32-CAM模块可广泛用于各种IoT应用中。它可以用作办公室、学校和其他私人区域中的面部检测系统，还可以用作无线监控、QR无线识别和许多其他物联网应用程序。ESP32-CAM模块可以使用ESP-IDF或ArduinoIDE进行编程。ESP32-CAM模块还具有多个GPIO引脚，用于连接外部硬件。...
ESP32-CAM 获取实时视频流
热门推荐
kkkkkk0729的博客
11-23 1万+
目录ESP32-CAM 通过局域网获取实时视频流一、开发环境准备二、设备连线连线图三、代码下载总结   ESP32-CAM 通过局域网获取实时视频流   注意: WIFI 频段要求 2.4 GHz！！！！！！(起初，我用手机开热点死活连不上，发现我热点频段设置的是 5GHz。。。)     一、开发环境准备     首先，下载 Arduino IDE，Arduino 中文社区的大佬很贴心，直接去下载，不限速。（安装结尾会提示安装驱动，建议全装.
ESP32-CAM自动拍摄照片并通过tcp协议上传至服务端
qq_62975494的博客
07-05 2156
①:esp32-cam拍摄照片并缓存②:esp32通过tcp协议将图片传输给服务端③：服务端将数据处理后将数据返回给esp32esp32收到返回数据后会继续拍摄并上传循环上述步骤。
使用RSTP协议，传输Esp32—Cam的视频
weixin_45796668的博客
09-17 1013
Real Time Streaming Protocol，RFC2326，实时流传输协议，RTSP是 TCP/IP 协议体系中的一个应用层协议，该协议定义了一对多应用程序如何有效地通过 IP 网络传送多媒体数据。HTTP与RTSP相比，HTTP传送HTML，而RTSP传送的是多媒体数据。然后点开基于rstp库协议的示例，接着进行密码和wifi名字的修改，然后进行编译烧录，连接成功后会生成一个地址。可以看到显示连接成功，并且生成了一个Http网址，复制到浏览器打开，可以看到网页版实时显示的视频。
esp32cam推流
09-25
要开始使用ESP32-CAM推流，您可以按照以下步骤进行配置和操作： 1. 首先，确保您已经配置了ESP32-CAM的Arduino开发环境。您可以参考引用中提供的步骤来配置开发环境。 2. 将ESP32-CAM通过串口与电脑连接，并确保电脑已经安装了串口驱动程序。在Arduino IDE中选择正确的端口进行配置，以便与ESP32-CAM进行通信。 3. 编译和烧录程序到ESP32-CAM。您可以按照引用中的步骤来完成这一步骤。 4. 烧录完成后，打开串口监视器并按下ESP32-CAM上的复位按钮（RST）。您应该能够在串口监视器中看到相关信息。 5. 打开一个浏览器，并输入ESP32-CAM的IP地址。默认情况下，可以尝试输入"192.168.80.192"。这将打开ESP32-CAM的网页界面。 6. 在网页界面上，您可以找到"start/stop stream"按钮。点击该按钮即可开始或停止推流。 请注意，上述步骤是一般的操作流程，具体的细节可能会因为不同的环境和项目要求而有所差异。您可以参考ESP32-CAM的官方文档（引用）以获取更详细的信息和指导。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值