对phoenix3k的esp32cam推流代码的改进

对于ESP32-CAM视频传输至公网服务器并转发视频数据流_esp32上传视频到服务器-优快云博客的代码进行改进。解决粘包问题，以及客户端由被动接收改为主动索取模式，以及esp32cam网络重连的调整：

esp32cam烧写内容：

 
#include <Arduino.h>
#include <WiFi.h>
#include "esp_camera.h"
#include <vector>
 
const char *ssid = "user"; //wifi用户名
const char *password = "password"; //wifi密码
const IPAddress serverIP(127,0,0,1);  //你自己的公网服务器ip地址
uint16_t serverPort = xxx;         //服务器端口号(tcp协议)
 
#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);
    int times = 0;
    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 sp(const char c[])
{
    Serial.print("BL(180);");
    Serial.print("CLR(16);");
    char buf[100] = {0};
    sprintf(buf,"DC16(30,60,\'%s\',3);",c);
    Serial.println(buf);
}

void spn(const char c[])
{
  sp(c);
}
 
void setup()
{
    Serial.begin(115200);
    wifi_init();
    camera_init();
}
 
void loop()
{
    spn("Try To Connect TCP Server!");
    if (client.connect(serverIP, serverPort)) //尝试访问目标地址
    {
        client.print("cam");
        spn("Connect Tcp Server Success!");
        int tick = 0;
        // client.println("Frame Begin");  //46 72 61 6D 65 20 42 65 67 69 6E // 0D 0A 代表换行  //向服务器发送数据
        while (1){  
          
          if(!client.connected())
          {
            spn("newwork is disconnected");
            break;
          }
          if(client.available()>0)     
          {
            char data[100] = {0};
            int ind = 0;
            while (client.available()>0) 
            {
              data[ind++] = client.read();//将读取到的数据存入字符串
            }
            if(!(data[0] = 'g' && data[1] == 'o'))
            {
              delay(30);
              spn("recv not go");
              break;
            }
          }
          else
          {
            tick ++;
            if(tick > 300)
            {
              break;
            }
            char sigstr[4] = {0};
            switch(tick%2)
            {
              case 0:
              strcpy(sigstr,"-");
              break;
              case 1:
              strcpy(sigstr,"|");
              break;
            }
            delay(500);
            spn(sigstr);
            delay(50);
            continue;
          }
          tick=0;
          camera_fb_t * fb = esp_camera_fb_get();
          uint8_t * temp = fb->buf; //这个是为了保存一个地址，在摄像头数据发送完毕后需要返回，否则会出现板子发送一段时间后自动重启，不断重复
          if (!fb)
          {
              spn( "Camera Capture Failed");
          }
          else
          { 
            //先发送Frame Begin 表示开始发送图片 然后将图片数据分包发送 每次发送1430 余数最后发送 
            //完毕后发送结束标志 Frame Over 表示一张图片发送完毕 
            client.println("Frame Begin"); //一张图片的起始标志
            // 将图片数据分段发送
            int leng = fb->len;
            char lenStr[100] = {0};
            itoa(leng,lenStr,10);
            strcat(lenStr,"bytes");
            client.write(lenStr,100);
            client.write(fb->buf,leng);
            fb->buf += leng;

            
            spn("This Frame Length:");
            spn(lenStr);
            spn(".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(30);//短暂延时 增加数据传输可靠性
        }        
    }
    else
    {
        spn("Connect To Tcp Server Failed!After 3 Seconds Try Again!");
        // client.stop(); //关闭客户端
    }
    delay(3000);
}

中转服务器的js:

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


/*************************file log*****************************/
const fs = require('fs');

function mylog(txt)
{
  console.log(txt)
  fs.appendFile('/root/vs.log', txt + '\n', err => {
    if (err) {
      console.error(err);
    }
    // file written successfully
  });
}

/*************************file log*****************************/
 
// 创建udp
// const dgram = require("dgram")
// const server = dgram.createSocket("udp4")
 
// 统计连接客户端的个数
var count = 0
 
// 创建slave_server服务
const slave_server = new net.createServer()
// slave_server.setEncoding = 'UTF-8'
 
// 保存监视器的socket
var s = 0
var cam = 0

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

接收内容的客户端py：

import socket
import threading
import time
import numpy as np
import cv2
 
begin_data = b'Frame Begin'
end_data = b'Frame Over'
 
def recvPack(sock,size):
    ilen = size
    remain = size
    ret = sock.recv(ilen)
    seg = ret
    while len(seg) < remain:
        remain = remain - len(seg)
        seg = sock.recv(remain)
        ret = ret + seg
    return ret
 
# 接收数据
# ESP32发送一张照片的流程
# 先发送113字节的前序帧，由Frame Begin开头，后面接图片尺寸。
# 完毕后发送结束标志 Frame Over 表示一张图片发送完毕
# 1430 来自ESP32cam发送的一个包大小为1430 接收到数据 data格式为b''
def handle_sock(sock, addr):
    
    temp_data = b''
    tick = 0
    while True:
        
        ilen = 113
        data = recvPack(sock,ilen)
        print("after recv")

        fsPos = data.find(b'Frame Begin')
        if fsPos != -1:
        # 如果这一帧数据包的开头是 b'Frame Begin' 则是一张图片的开始
            print("Frame Begin")
            #如果在113的包尾，则继续接收10个字节保证内容完整
            addSize = 0
            if fsPos > 90:
                addSize = 20
                addData = recvPack(sock,addSize)
                data = data + addData

                
            # 将这一帧数据包的开始标志信息（b'Frame Begin/r/n'）清除   因为他不属于图片数据
            data = data[fsPos + 13:len(data) + addSize]
            dataStr = str(data)
            pos = dataStr.find("bytes")
            lenStr = dataStr[2:pos]
            print("size in head:" + lenStr)
            ilen = int(lenStr)

            offset = recvPack(sock,fsPos - addSize)

            temp_data = recvPack(sock,ilen)
            print("recv pack len:" + str(len(temp_data)))
            if len(temp_data) != ilen:
                sock.sendall(b'continue')
                continue
            # hdr = temp_data[0:2]
            # print("hdr:"+ str(hdr))

            # 显示图片
            print(len(temp_data))
            receive_data = np.frombuffer(temp_data, dtype='uint8')  # 将获取到的字符流数据转换成1维数组
            print("begin handle frame")
            r_img = cv2.imdecode(receive_data, cv2.IMREAD_COLOR)  # 将数组解码成图像
            # r_img = r_img.reshape(480, 640, 3)

            # if tick % 10 == 0:
            #     print("tick ok" + str(tick))
            # cv2.putText(r_img, "po", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
            cv2.imshow('server_frame', r_img)
            if cv2.waitKey(25) & 0xFF == ord('q'):
                cv2.destroyAllWindows()
                break
            # print("接收到的数据包大小：" + str(len(temp_data)))  # 显示该张照片数据大小
            temp_data = b''  # 清空数据 便于下一章照片使用
            time.sleep(1)
            sock.sendall(b'continue')
 
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.connect(("xxx.xxx", xxxx))
server.send('monitor'.encode("utf-8"))

 
# 主线程循环接收客户端连接
handle_sock(server, '')  # mac电脑直接在主线程运行