Horldsence/ESP32S3_vt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b74c6654e5f48262a76b8539f208f55318fa8479
ESP32S3_vt/components/esp32-camera/sensors/mega_ccm.c
T
Horldsence 4f893ce140 ESP32-S3 摄像头图传：固件 + Slint 客户端 + 共享协议 
两块 ESP32-S3-WROOM-1-N16R8 图传板（DVP 接口接 OV2640/OV3660/OV5640），
向队伍客户端与裁判终端推 UDP 图传。固件是跑在 ESP-IDF 上的 Rust，用官方
esp32-camera 组件采集；客户端是 Rust + Slint 桌面程序。

三个 crate 各自独立构建：
  .            firmware，交叉编译到 Xtensa
  protocol/    线路格式与帧重组，两端共用，无 ESP-IDF 依赖，有单元测试
  client/      Slint 桌面客户端

视频走 UDP 而非 TCP：实测传感器产出 22 fps，TCP MJPEG 只送出 1.9 fps，
且只占用链路能力的 1%——链路是空的，帧堵在队头阻塞后面等一个实时画面
等不起的重传计时器。改为独立数据报、不重传、缺片丢整帧后达到 20.8 fps。

发现是双向的：板子每 2 秒广播 Hello，客户端广播 Subscribe，板子据此定向
推流。板子身份由 MAC 派生，重启不变，所以客户端可以把绑定存进配置。

裁判端同时收两块板子（每个发送方一个重组器），队伍端绑定其中一块并只显示
自己那一边的血量。装甲板接口已预留（ArmorSource trait + ARMOR_PORT），
当前无数据源，界面显示占位符。

vendor 了 esp32-camera 2.1.7：组件注册表的版本求解器找不到它，且需要打一处
补丁（见 components/esp32-camera/target/esp32s3/ll_cam.c）。

.gitignore 三条 target/ 都锚定在根目录，因为 protocol/ 与 client/ 各自也是
独立 crate；而 components/esp32-camera/target/ 是上游的按芯片分目录，里面是
源码，必须保留。
2026-10-05 18:22:19 +08:00

416 lines
11 KiB
C
Raw Blame History

// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sccb.h"
#include "mega_ccm.h"
#include "mega_ccm_regs.h"
#include "mega_ccm_settings.h"
#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
#include "esp32-hal-log.h"
#else
#include "esp_log.h"
static const char *TAG = "mega_ccm";
#endif
#define H8(v) ((v)>>8)
#define L8(v) ((v)&0xff)
//#define REG_DEBUG_ON
static int read_reg(uint8_t slv_addr, const uint16_t reg){
int ret = SCCB_Read16(slv_addr, reg);
#ifdef REG_DEBUG_ON
if (ret < 0) {
ESP_LOGE(TAG, "READ REG 0x%04x FAILED: %d", reg, ret);
}
#endif
return ret;
}
static int write_reg(uint8_t slv_addr, const uint16_t reg, uint8_t value){
int ret = 0;
ret = SCCB_Write16(slv_addr, reg, value);
return ret;
}
static int reset(sensor_t *sensor)
{
int ret;
ret = write_reg(sensor->slv_addr, CAMERA_RST_REG, 0x00);
ret += write_reg(sensor->slv_addr, CAMERA_RST_REG, 0x01);
vTaskDelay(1000 / portTICK_PERIOD_MS);
return ret;
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
{
int ret = 0;
switch (pixformat) {
case PIXFORMAT_JPEG:
ret = write_reg(sensor->slv_addr, PIXEL_FMT_REG, 0x01);
break;
case PIXFORMAT_RGB565:
ret = write_reg(sensor->slv_addr, PIXEL_FMT_REG, 0x02);
break;
case PIXFORMAT_YUV422:
ret = write_reg(sensor->slv_addr, PIXEL_FMT_REG, 0x03);
break;
default:
ESP_LOGW(TAG, "unsupported format");
ret = -1;
break;
}
if (ret == 0) {
sensor->pixformat = pixformat;
ESP_LOGD(TAG, "Set pixformat to: %u", pixformat);
}
return ret;
}
static int set_framesize(sensor_t *sensor, framesize_t framesize)
{
ESP_LOGI(TAG, "set_framesize");
int ret = 0;
if (framesize > FRAMESIZE_5MP) {
ESP_LOGW(TAG, "Invalid framesize: %u", framesize);
framesize = FRAMESIZE_5MP;
}
sensor->status.framesize = framesize;
uint16_t w = resolution[framesize].width;
uint16_t h = resolution[framesize].height;
switch (framesize){
case FRAMESIZE_QVGA:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x01); //320x240
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
break;
case FRAMESIZE_VGA:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x02); //640x480
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
break;
case FRAMESIZE_HD:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x03); //1280x720
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
break;
case FRAMESIZE_UXGA:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x04); //1600x1200
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
break;
case FRAMESIZE_FHD:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x05); //1920x1080
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
break;
case FRAMESIZE_5MP:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x06); //2592x1944
break;
case FRAMESIZE_96X96:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x07); //96x96
break;
case FRAMESIZE_128X128:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x08); //128x128
break;
case FRAMESIZE_320X320:
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x09); //320x320
break;
default:
ESP_LOGW(TAG, "unsupported framesize");
ret = -1;
break;
}
if (ret == 0) {
ESP_LOGD(TAG, "Set framesize to: %ux%u", w, h);
}
return ret;
}
static int set_hmirror(sensor_t *sensor, int enable)
{
int ret = 0;
sensor->status.hmirror = enable;
ret = write_reg(sensor->slv_addr, IMAGE_MIRROR_REG, enable);
if (ret == 0) {
ESP_LOGD(TAG, "Set h-mirror to: %d", enable);
}
return ret;
}
static int set_vflip(sensor_t *sensor, int enable)
{
int ret = 0;
sensor->status.vflip = enable;
ret = write_reg(sensor->slv_addr, IMAGE_FLIP_REG, enable);
if (ret == 0) {
ESP_LOGD(TAG, "Set v-flip to: %d", enable);
}
return ret;
}
static int set_quality(sensor_t *sensor, int qs)
{
int ret = 0;
ret = write_reg(sensor->slv_addr, IMAGE_QUALITY_REG, qs);
if (ret == 0) {
sensor->status.quality = qs;
ESP_LOGD(TAG, "Set quality to: %d", qs);
}
return ret;
}
static int set_brightness(sensor_t *sensor, int level)
{
int ret = 0;
if(level < 0) {
level = 0;
} else if(level > 8) {
level = 8;
}
ret = write_reg(sensor->slv_addr, BRIGHTNESS_REG, level);
if (ret == 0) {
ESP_LOGD(TAG, "Set brightness to: %d", level);
sensor->status.brightness = level;
}
return ret;
}
static int set_contrast (sensor_t *sensor, int level)
{
int ret = 0;
if(level < 0) {
level = 0;
} else if(level > 6) {
level = 6;
}
ret = write_reg(sensor->slv_addr, CONTRAST_REG, level);
if (ret == 0) {
ESP_LOGD(TAG, "Set contrast to: %d", level);
sensor->status.contrast = level;
}
return ret;
}
static int set_saturation (sensor_t *sensor, int level)
{
int ret = 0;
if(level < 0) {
level = 0;
} else if(level > 6) {
level = 6;
}
ret = write_reg(sensor->slv_addr, SATURATION_REG, level);
if (ret == 0) {
ESP_LOGD(TAG, "Set saturation to: %d", level);
sensor->status.saturation = level;
}
return ret;
}
static int set_agc_mode (sensor_t *sensor, int enable)
{
int ret = 0;
ret = write_reg(sensor->slv_addr, AGC_MODE_REG, enable);
if (ret == 0) {
ESP_LOGD(TAG, "Set agc mode to: %d", enable);
sensor->status.aec = enable;
}
return ret;
}
static int set_wb_mode (sensor_t *sensor, int mode)
{
int ret = 0;
if(mode < 0) {
mode = 0;
} else if(mode > 5) {
mode = 5;
}
ret = write_reg(sensor->slv_addr, AWB_MODE_REG, mode);
if (ret == 0) {
ESP_LOGD(TAG, "Set wb_mode to: %d", mode);
sensor->status.wb_mode = mode;
}
return ret;
}
static int set_special_effect (sensor_t *sensor, int effect)
{
int ret = 0;
if(effect < 0) {
effect = 0;
} else if(effect > 6) {
effect = 6;
}
ret = write_reg(sensor->slv_addr, SPECIAL_REG, effect);
if (ret == 0) {
ESP_LOGD(TAG, "Set special_effect to: %d", effect);
sensor->status.special_effect = effect;
}
return ret;
}
static int analog_gain (sensor_t *sensor, int val)
{
int ret = 0;
ret = write_reg(sensor->slv_addr, MANUAL_AGC_REG, val);
if (ret == 0) {
ESP_LOGD(TAG, "Set analog gain to: %d", val);
}
return ret;
}
static int exposure_line (sensor_t *sensor, int val)
{
int ret = 0;
ret = write_reg(sensor->slv_addr, MANUAL_EXP_H_REG, val>>8);
ret += write_reg(sensor->slv_addr, MANUAL_EXP_L_REG, val>>8);
if (ret == 0) {
ESP_LOGD(TAG, "Set exposure_line to: %d", val);
}
return ret;
}
static int init_status(sensor_t *sensor)
{
sensor->status.brightness = 0;
sensor->status.contrast = 0;
sensor->status.saturation = 0;
sensor->status.sharpness = 0;
sensor->status.denoise = 0;
sensor->status.ae_level = 0;
sensor->status.gainceiling = 0;
sensor->status.awb = 0;
sensor->status.dcw = 0;
sensor->status.agc = 0;
sensor->status.aec = 0;
sensor->status.hmirror = 0;
sensor->status.vflip = 0;
sensor->status.colorbar = 0;
sensor->status.bpc = 0;
sensor->status.wpc = 0;
sensor->status.raw_gma = 0;
sensor->status.lenc = 0;
sensor->status.quality = 0;
sensor->status.special_effect = 0;
sensor->status.wb_mode = 0;
sensor->status.awb_gain = 0;
sensor->status.agc_gain = 0;
sensor->status.aec_value = 0;
sensor->status.aec2 = 0;
return 0;
}
static int set_dummy(sensor_t *sensor, int val)
{
ESP_LOGW(TAG, "Unsupported");
return -1;
}
static int set_gainceiling_dummy(sensor_t *sensor, gainceiling_t val)
{
ESP_LOGW(TAG, "Unsupported");
return -1;
}
int esp32_camera_mega_ccm_detect(int slv_addr, sensor_id_t *id)
{
if (MEGA_CCM_SCCB_ADDR == slv_addr) {
uint8_t h = read_reg(slv_addr, SENSOR_ID_HIGH);
uint8_t l = read_reg(slv_addr, SENSOR_ID_LOW);
uint16_t PID = (h<<8) | l;
if (MEGA_CCM_PID == PID) {
id->PID = PID;
return PID;
} else {
ESP_LOGI(TAG, "Mismatch PID=0x%x", PID);
}
}
return 0;
}
int esp32_camera_mega_ccm_init(sensor_t *sensor)
{
sensor->init_status = init_status;
sensor->reset = reset;
sensor->set_pixformat = set_pixformat;
sensor->set_framesize = set_framesize;
sensor->set_contrast = set_contrast;
sensor->set_brightness = set_brightness;
sensor->set_saturation = set_saturation;
sensor->set_sharpness = set_dummy;
sensor->set_denoise = set_dummy;
sensor->set_gainceiling = set_gainceiling_dummy;
sensor->set_quality = set_quality;
sensor->set_colorbar = set_dummy;
sensor->set_whitebal = set_dummy;
sensor->set_gain_ctrl = set_dummy;
sensor->set_exposure_ctrl = set_dummy;
sensor->set_hmirror = set_hmirror;
sensor->set_vflip = set_vflip;
sensor->set_aec2 = set_agc_mode;
sensor->set_awb_gain = set_dummy;
sensor->set_agc_gain = analog_gain;
sensor->set_aec_value = exposure_line;
sensor->set_special_effect = set_special_effect;
sensor->set_wb_mode = set_wb_mode;
sensor->set_ae_level = set_dummy;
sensor->set_dcw = set_dummy;
sensor->set_bpc = set_dummy;
sensor->set_wpc = set_dummy;
sensor->set_raw_gma = set_dummy;
sensor->set_lenc = set_dummy;
sensor->get_reg = NULL;
sensor->set_reg = NULL;
sensor->set_res_raw = NULL;
sensor->set_pll = NULL;
sensor->set_xclk = NULL;
// No autofocus support
sensor->af_is_supported = NULL;
sensor->af_init = NULL;
sensor->af_set_mode = NULL;
sensor->af_trigger = NULL;
sensor->af_get_status = NULL;
sensor->af_set_manual_position = NULL;
ESP_LOGD(TAG, "MEGA_CCM Attached");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink