894 lines
33 KiB
C#
894 lines
33 KiB
C#
using System.Net;
|
||
using DotNext;
|
||
|
||
namespace Peripherals.CameraClient;
|
||
|
||
static class CameraAddr
|
||
{
|
||
public const UInt32 BASE = 0x7000_0000;
|
||
|
||
public const UInt32 STORE_ADDR = BASE + 0x12;
|
||
public const UInt32 STORE_NUM = BASE + 0x13;
|
||
public const UInt32 EXPECTED_VH = BASE + 0x14;
|
||
public const UInt32 CAPTURE_ON = BASE + 0x15;
|
||
}
|
||
|
||
class Camera
|
||
{
|
||
private static readonly NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
|
||
|
||
readonly int timeout = 2000;
|
||
readonly int taskID;
|
||
readonly int port;
|
||
readonly string address;
|
||
private IPEndPoint ep;
|
||
|
||
|
||
const uint CAM_I2C_ADDR = 0x3C;
|
||
const Peripherals.I2cClient.I2cProtocol CAM_PROTO = Peripherals.I2cClient.I2cProtocol.SCCB;
|
||
const byte PLL_MUX = 10;
|
||
const UInt32 FrameAddr = 0x00;
|
||
|
||
// 动态分辨率参数
|
||
private UInt16 _currentWidth = 640;
|
||
private UInt16 _currentHeight = 480;
|
||
private UInt32 _currentFrameLength = 640 * 480 * 2 / 4; // RGB565格式，2字节/像素，按4字节对齐
|
||
|
||
|
||
/// <summary>
|
||
/// 初始化摄像头客户端
|
||
/// </summary>
|
||
/// <param name="address">摄像头设备IP地址</param>
|
||
/// <param name="port">摄像头设备端口</param>
|
||
/// <param name="timeout">超时时间（毫秒）</param>
|
||
public Camera(string address, int port, int timeout = 2000)
|
||
{
|
||
if (timeout < 0)
|
||
throw new ArgumentException("Timeout couldn't be negative", nameof(timeout));
|
||
this.address = address;
|
||
this.port = port;
|
||
this.ep = new IPEndPoint(IPAddress.Parse(address), port);
|
||
this.timeout = timeout;
|
||
}
|
||
|
||
public async ValueTask<Result<bool>> Init()
|
||
{
|
||
// 步骤1: 复位
|
||
var resetResult = await Reset();
|
||
if (!resetResult.IsSuccessful) return resetResult;
|
||
|
||
// 步骤2: 休眠
|
||
var sleepResult = await Sleep();
|
||
if (!sleepResult.IsSuccessful) return sleepResult;
|
||
|
||
// 步骤3: 配置基础寄存器
|
||
var basicResult = await ConfigureBasicRegisters();
|
||
if (!basicResult.IsSuccessful) return basicResult;
|
||
|
||
// 步骤4: 配置传感器控制
|
||
var sensorResult = await ConfigureSensorControl();
|
||
if (!sensorResult.IsSuccessful) return sensorResult;
|
||
|
||
// 步骤5: 配置模拟控制
|
||
var analogResult = await ConfigureAnalogControl();
|
||
if (!analogResult.IsSuccessful) return analogResult;
|
||
|
||
// 步骤6: 配置时钟控制
|
||
var clockResult = await ConfigureClockControl();
|
||
if (!clockResult.IsSuccessful) return clockResult;
|
||
|
||
// 步骤7: 配置PSRAM控制
|
||
var psramResult = await ConfigurePSRAMControl();
|
||
if (!psramResult.IsSuccessful) return psramResult;
|
||
|
||
// 步骤8: 配置DVP时序
|
||
var dvpResult = await ConfigureDVPTiming();
|
||
if (!dvpResult.IsSuccessful) return dvpResult;
|
||
|
||
// 步骤9: 配置基础控制
|
||
var baseResult = await ConfigureBaseControl();
|
||
if (!baseResult.IsSuccessful) return baseResult;
|
||
|
||
// 步骤10: 配置图像格式
|
||
var formatResult = await ConfigureImageFormat();
|
||
if (!formatResult.IsSuccessful) return formatResult;
|
||
|
||
// 步骤11: 配置ISP控制
|
||
var ispResult = await ConfigureISPControl();
|
||
if (!ispResult.IsSuccessful) return ispResult;
|
||
|
||
// 步骤12: 配置AEC
|
||
var aecResult = await ConfigureAEC();
|
||
if (!aecResult.IsSuccessful) return aecResult;
|
||
|
||
// 步骤13: 配置LENC
|
||
var lencResult = await ConfigureLENC();
|
||
if (!lencResult.IsSuccessful) return lencResult;
|
||
|
||
// 步骤14: 配置AWB
|
||
var awbResult = await ConfigureAWB();
|
||
if (!awbResult.IsSuccessful) return awbResult;
|
||
|
||
// 步骤15: 配置Gamma
|
||
var gammaResult = await ConfigureGamma();
|
||
if (!gammaResult.IsSuccessful) return gammaResult;
|
||
|
||
// 步骤16: 配置CMX
|
||
var cmxResult = await ConfigureCMX();
|
||
if (!cmxResult.IsSuccessful) return cmxResult;
|
||
|
||
// 步骤17: 配置SDE
|
||
var sdeResult = await ConfigureSDE();
|
||
if (!sdeResult.IsSuccessful) return sdeResult;
|
||
|
||
// 步骤18: 配置CIP
|
||
var cipResult = await ConfigureCIP();
|
||
if (!cipResult.IsSuccessful) return cipResult;
|
||
|
||
// 步骤19: 配置时序控制
|
||
var timingResult = await ConfigureTimingControl();
|
||
if (!timingResult.IsSuccessful) return timingResult;
|
||
|
||
// 步骤20: 配置测试和闪光灯
|
||
var testResult = await ConfigureTestAndFlash();
|
||
if (!testResult.IsSuccessful) return testResult;
|
||
|
||
// 步骤21: 配置分辨率（默认640x480）
|
||
// var resolutionResult = await ConfigureResolution640x480();
|
||
var resolutionResult = await ConfigureResolution1280x720();
|
||
if (!resolutionResult.IsSuccessful) return resolutionResult;
|
||
|
||
// 步骤22: 开始流
|
||
var startResult = await StartStreaming();
|
||
if (!startResult.IsSuccessful) return startResult;
|
||
|
||
return true;
|
||
}
|
||
|
||
public async ValueTask<Result<bool>> EnableCamera(bool isEnable)
|
||
{
|
||
var ret = await UDPClientPool.WriteAddr(this.ep, this.taskID, CameraAddr.CAPTURE_ON, Convert.ToUInt32(isEnable));
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error($"Failed to write CAPTURE_ON to camera at {this.address}:{this.port}, error: {ret.Error}");
|
||
return new(ret.Error);
|
||
}
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error($"CAPTURE_ON write returned false for camera at {this.address}:{this.port}");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取一帧图像数据
|
||
/// </summary>
|
||
/// <returns>包含图像数据的字节数组</returns>
|
||
public async ValueTask<Result<byte[]>> ReadFrame()
|
||
{
|
||
// 只在第一次或出错时清除UDP缓冲区，避免每帧都清除造成延迟
|
||
// await MsgBus.UDPServer.ClearUDPData(this.address, this.taskID);
|
||
|
||
logger.Trace($"Reading frame from camera {this.address}");
|
||
|
||
// 使用UDPClientPool读取图像帧数据
|
||
var result = await UDPClientPool.ReadAddr4Bytes(
|
||
this.ep,
|
||
this.taskID, // taskID
|
||
FrameAddr,
|
||
(int)(_currentWidth * _currentHeight * 2), // 使用当前分辨率的动态大小
|
||
this.timeout);
|
||
|
||
if (!result.IsSuccessful)
|
||
{
|
||
logger.Error($"Failed to read frame from camera {this.address}:{this.port}, error: {result.Error}");
|
||
// 读取失败时清除缓冲区，为下次读取做准备
|
||
try
|
||
{
|
||
await MsgBus.UDPServer.ClearUDPData(this.address, this.taskID);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Warn($"Failed to clear UDP data after read error: {ex.Message}");
|
||
}
|
||
return new(result.Error);
|
||
}
|
||
|
||
logger.Trace($"Successfully read frame from camera {this.address}:{this.port}, data length: {result.Value.Length} bytes");
|
||
return result.Value;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量配置I2C寄存器
|
||
/// </summary>
|
||
/// <param name="registerTable">寄存器配置表，每个元素包含3个字节：[地址高位, 地址低位, 数据]</param>
|
||
/// <param name="customDelayMs">自定义延时时间（毫秒），如果为null则使用默认延时逻辑</param>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureRegisters(byte[][] registerTable, int? customDelayMs = null)
|
||
{
|
||
var i2c = new Peripherals.I2cClient.I2c(this.address, this.port, this.taskID, this.timeout);
|
||
|
||
foreach (var cmd in registerTable)
|
||
{
|
||
if (cmd.Length != 3)
|
||
{
|
||
logger.Error($"Invalid register command length: {cmd.Length}, expected 3 bytes");
|
||
return new(new ArgumentException($"Invalid register command length: {cmd.Length}, expected 3 bytes"));
|
||
}
|
||
|
||
var ret = await i2c.WriteData(CAM_I2C_ADDR, cmd, CAM_PROTO);
|
||
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error($"I2C write 0x{CAM_I2C_ADDR.ToString("X")} failed: {BitConverter.ToString(cmd)} error: {ret.Error}");
|
||
return new(ret.Error);
|
||
}
|
||
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error($"I2C write 0x{CAM_I2C_ADDR.ToString("X")} returned false: {BitConverter.ToString(cmd)}");
|
||
return false;
|
||
}
|
||
|
||
// 处理延时逻辑
|
||
if (customDelayMs.HasValue)
|
||
{
|
||
await Task.Delay(customDelayMs.Value);
|
||
}
|
||
else
|
||
{
|
||
// 使用默认延时逻辑
|
||
if (cmd[0] == 0x30 && cmd[1] == 0x08 && cmd[2] == 0x82)
|
||
{
|
||
// 复位命令，等待5MS
|
||
await Task.Delay(5);
|
||
}
|
||
else
|
||
{
|
||
await Task.Delay(3); // 其他命令延时3ms
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置摄像头分辨率和相关参数
|
||
/// </summary>
|
||
/// <param name="hStart">水平起始位置</param>
|
||
/// <param name="vStart">垂直起始位置</param>
|
||
/// <param name="dvpHo">输出水平像素数</param>
|
||
/// <param name="dvpVo">输出垂直像素数</param>
|
||
/// <param name="hts">水平总像素数</param>
|
||
/// <param name="vts">垂直总像素数</param>
|
||
/// <param name="hOffset">水平偏移</param>
|
||
/// <param name="vOffset">垂直偏移</param>
|
||
/// <param name="hWindow">水平窗口大小（默认1500）</param>
|
||
/// <param name="vWindow">垂直窗口大小（默认1300）</param>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureResolution(
|
||
UInt16 hStart, UInt16 vStart,
|
||
UInt16 dvpHo, UInt16 dvpVo,
|
||
UInt16 hts, UInt16 vts,
|
||
UInt16 hOffset, UInt16 vOffset,
|
||
UInt16 hWindow = 1500, UInt16 vWindow = 1300)
|
||
{
|
||
// 计算结束位置
|
||
UInt16 hEnd = (UInt16)(hStart + hWindow - 1);
|
||
UInt16 vEnd = (UInt16)(vStart + vWindow - 1);
|
||
|
||
// 计算帧长度
|
||
UInt32 frameLength = (UInt32)(dvpHo * dvpVo * 16 / 32);
|
||
|
||
// 1. 配置UDP相关寄存器
|
||
{
|
||
var ret = await UDPClientPool.WriteAddr(this.ep, this.taskID, CameraAddr.STORE_ADDR, FrameAddr);
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error($"Failed to write STORE_ADDR: {ret.Error}");
|
||
return new(ret.Error);
|
||
}
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error("STORE_ADDR write returned false");
|
||
return new(new Exception("STORE_ADDR write returned false"));
|
||
}
|
||
}
|
||
|
||
{
|
||
var ret = await UDPClientPool.WriteAddr(this.ep, this.taskID, CameraAddr.STORE_NUM, frameLength);
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error($"Failed to write STORE_NUM: {ret.Error}");
|
||
return new(ret.Error);
|
||
}
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error("STORE_NUM write returned false");
|
||
return new(new Exception("STORE_NUM write returned false"));
|
||
}
|
||
}
|
||
|
||
{
|
||
var ret = await UDPClientPool.WriteAddr(this.ep, this.taskID, CameraAddr.EXPECTED_VH, ((uint)dvpVo) << 16 | ((uint)dvpHo * 2));
|
||
if (!ret.IsSuccessful)
|
||
{
|
||
logger.Error($"Failed to write EXPECTED_VH: {ret.Error}");
|
||
return new(ret.Error);
|
||
}
|
||
if (!ret.Value)
|
||
{
|
||
logger.Error("EXPECTED_VH write returned false");
|
||
return new(new Exception("EXPECTED_VH write returned false"));
|
||
}
|
||
}
|
||
|
||
// 2. 配置I2C寄存器
|
||
var resolutionRegisters = new byte[][]
|
||
{
|
||
// H_OFFSET/V_OFFSET
|
||
new byte[] { 0x38, 0x10, unchecked((byte)((hOffset >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x11, unchecked((byte)(hOffset & 0xFF)) },
|
||
new byte[] { 0x38, 0x12, unchecked((byte)((vOffset >> 8) & 0xFF)) },
|
||
|
||
// H_START/V_START
|
||
new byte[] { 0x38, 0x00, unchecked((byte)((hStart >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x01, unchecked((byte)(hStart & 0xFF)) },
|
||
new byte[] { 0x38, 0x02, unchecked((byte)((vStart >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x03, unchecked((byte)(vStart & 0xFF)) },
|
||
|
||
// H_END/V_END
|
||
new byte[] { 0x38, 0x04, unchecked((byte)((hEnd >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x05, unchecked((byte)(hEnd & 0xFF)) },
|
||
new byte[] { 0x38, 0x06, unchecked((byte)((vEnd >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x07, unchecked((byte)(vEnd & 0xFF)) },
|
||
|
||
// 输出像素个数
|
||
new byte[] { 0x38, 0x08, unchecked((byte)((dvpHo >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x09, unchecked((byte)(dvpHo & 0xFF)) },
|
||
new byte[] { 0x38, 0x0A, unchecked((byte)((dvpVo >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x0B, unchecked((byte)(dvpVo & 0xFF)) },
|
||
|
||
// 总像素
|
||
new byte[] { 0x38, 0x0C, unchecked((byte)((hts >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x0D, unchecked((byte)(hts & 0xFF)) },
|
||
new byte[] { 0x38, 0x0E, unchecked((byte)((vts >> 8) & 0xFF)) },
|
||
new byte[] { 0x38, 0x0F, unchecked((byte)(vts & 0xFF)) },
|
||
|
||
// Timing Voffset
|
||
new byte[] { 0x38, 0x13, unchecked((byte)(vOffset & 0xFF)) }
|
||
};
|
||
|
||
var configResult = await ConfigureRegisters(resolutionRegisters, customDelayMs: 1);
|
||
if (!configResult.IsSuccessful)
|
||
{
|
||
logger.Error($"Failed to configure resolution registers: {configResult.Error}");
|
||
return configResult;
|
||
}
|
||
|
||
logger.Info($"Successfully configured resolution: {dvpHo}x{dvpVo}, HTS={hts}, VTS={vts}");
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置为640x480分辨率（默认配置）
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureResolution640x480()
|
||
{
|
||
return await ConfigureResolution(
|
||
hStart: 0, vStart: 0,
|
||
dvpHo: 640, dvpVo: 480,
|
||
hts: 1700, vts: 1500,
|
||
hOffset: 16, vOffset: 4
|
||
);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置为320x240分辨率
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureResolution320x240()
|
||
{
|
||
return await ConfigureResolution(
|
||
hStart: 0, vStart: 0,
|
||
dvpHo: 320, dvpVo: 240,
|
||
hts: 850, vts: 750,
|
||
hOffset: 16, vOffset: 4,
|
||
hWindow: 750, vWindow: 650
|
||
);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置为1280x720分辨率
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureResolution1280x720()
|
||
{
|
||
return await ConfigureResolution(
|
||
hStart: 0, vStart: 0,
|
||
dvpHo: 1280, dvpVo: 720,
|
||
hts: 2844, vts: 1968,
|
||
hOffset: 16, vOffset: 4,
|
||
hWindow: 2592, vWindow: 1944
|
||
);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 切换摄像头分辨率
|
||
/// </summary>
|
||
/// <param name="width">宽度</param>
|
||
/// <param name="height">高度</param>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ChangeResolution(int width, int height)
|
||
{
|
||
try
|
||
{
|
||
logger.Info($"正在切换摄像头分辨率到 {width}x{height}");
|
||
|
||
Result<bool> result;
|
||
switch ($"{width}x{height}")
|
||
{
|
||
case "640x480":
|
||
result = await ConfigureResolution640x480();
|
||
break;
|
||
case "1280x720":
|
||
result = await ConfigureResolution1280x720();
|
||
break;
|
||
default:
|
||
logger.Error($"不支持的分辨率: {width}x{height}");
|
||
return new(new ArgumentException($"不支持的分辨率: {width}x{height}"));
|
||
}
|
||
|
||
if (result.IsSuccessful)
|
||
{
|
||
_currentWidth = (UInt16)width;
|
||
_currentHeight = (UInt16)height;
|
||
_currentFrameLength = (UInt32)(width * height * 2 / 4); // RGB565格式，按4字节对齐
|
||
logger.Info($"摄像头分辨率已切换到 {width}x{height}");
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.Error(ex, $"切换分辨率到 {width}x{height} 时发生错误");
|
||
return new(ex);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取当前分辨率
|
||
/// </summary>
|
||
/// <returns>当前分辨率(宽度, 高度)</returns>
|
||
public (int Width, int Height) GetCurrentResolution()
|
||
{
|
||
return (_currentWidth, _currentHeight);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取当前帧长度
|
||
/// </summary>
|
||
/// <returns>当前帧长度</returns>
|
||
public UInt32 GetCurrentFrameLength()
|
||
{
|
||
return _currentFrameLength;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 复位摄像头
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> Reset()
|
||
{
|
||
var resetRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x30, 0x08, 0x82 } // 复位命令
|
||
};
|
||
|
||
return await ConfigureRegisters(resetRegisters, customDelayMs: 5); // 复位后等待5ms
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置摄像头为休眠模式
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> Sleep()
|
||
{
|
||
var sleepRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x30, 0x08, 0x42 } // 休眠命令
|
||
};
|
||
|
||
return await ConfigureRegisters(sleepRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置基础寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureBasicRegisters()
|
||
{
|
||
var basicRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x31, 0x03, 0x02 },
|
||
new byte[] { 0x30, 0x17, 0xff },
|
||
new byte[] { 0x30, 0x18, 0xff },
|
||
new byte[] { 0x30, 0x37, 0x13 },
|
||
new byte[] { 0x31, 0x08, 0x01 }
|
||
};
|
||
|
||
return await ConfigureRegisters(basicRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置传感器控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureSensorControl()
|
||
{
|
||
var sensorRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x36, 0x30, 0x36 },
|
||
new byte[] { 0x36, 0x31, 0x0e },
|
||
new byte[] { 0x36, 0x32, 0xe2 },
|
||
new byte[] { 0x36, 0x33, 0x12 },
|
||
new byte[] { 0x36, 0x21, 0xe0 }
|
||
};
|
||
|
||
return await ConfigureRegisters(sensorRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置模拟控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureAnalogControl()
|
||
{
|
||
var analogRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x37, 0x04, 0xa0 },
|
||
new byte[] { 0x37, 0x03, 0x5a },
|
||
new byte[] { 0x37, 0x15, 0x78 },
|
||
new byte[] { 0x37, 0x17, 0x01 },
|
||
new byte[] { 0x37, 0x0b, 0x60 },
|
||
new byte[] { 0x37, 0x05, 0x1a }
|
||
};
|
||
|
||
return await ConfigureRegisters(analogRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置时钟控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureClockControl()
|
||
{
|
||
var clockRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x39, 0x05, 0x02 },
|
||
new byte[] { 0x39, 0x06, 0x10 },
|
||
new byte[] { 0x39, 0x01, 0x0a },
|
||
new byte[] { 0x30, 0x35, 0x11 }, // 30fps
|
||
new byte[] { 0x30, 0x36, PLL_MUX } // PLL倍频
|
||
};
|
||
|
||
return await ConfigureRegisters(clockRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置PSRAM控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigurePSRAMControl()
|
||
{
|
||
var psramRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x37, 0x31, 0x12 },
|
||
new byte[] { 0x36, 0x00, 0x08 },
|
||
new byte[] { 0x36, 0x01, 0x33 },
|
||
new byte[] { 0x30, 0x2d, 0x60 },
|
||
new byte[] { 0x36, 0x20, 0x52 },
|
||
new byte[] { 0x37, 0x1b, 0x20 },
|
||
new byte[] { 0x47, 0x1c, 0x50 }
|
||
};
|
||
|
||
return await ConfigureRegisters(psramRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置DVP时序寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureDVPTiming()
|
||
{
|
||
var dvpRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x3a, 0x13, 0x43 },
|
||
new byte[] { 0x3a, 0x18, 0x00 },
|
||
new byte[] { 0x3a, 0x19, 0xf8 },
|
||
new byte[] { 0x36, 0x35, 0x13 },
|
||
new byte[] { 0x36, 0x36, 0x03 },
|
||
new byte[] { 0x36, 0x34, 0x40 },
|
||
new byte[] { 0x36, 0x22, 0x01 }
|
||
};
|
||
|
||
return await ConfigureRegisters(dvpRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置基础控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureBaseControl()
|
||
{
|
||
var baseRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x3c, 0x01, 0x34 },
|
||
new byte[] { 0x3c, 0x04, 0x28 },
|
||
new byte[] { 0x3c, 0x05, 0x98 },
|
||
new byte[] { 0x3c, 0x06, 0x00 },
|
||
new byte[] { 0x3c, 0x07, 0x08 },
|
||
new byte[] { 0x3c, 0x08, 0x00 },
|
||
new byte[] { 0x3c, 0x09, 0x1c },
|
||
new byte[] { 0x3c, 0x0a, 0x9c },
|
||
new byte[] { 0x3c, 0x0b, 0x40 },
|
||
new byte[] { 0x37, 0x08, 0x64 }
|
||
};
|
||
|
||
return await ConfigureRegisters(baseRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置图像格式寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureImageFormat()
|
||
{
|
||
var formatRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x40, 0x01, 0x02 },
|
||
new byte[] { 0x40, 0x05, 0x1a },
|
||
new byte[] { 0x30, 0x00, 0x00 },
|
||
new byte[] { 0x30, 0x04, 0xff },
|
||
new byte[] { 0x43, 0x00, 0x6F }, // RGB565:first byte:{g[2:0],b[4:0]],second byte:{r[4:0],g[5:3]}
|
||
new byte[] { 0x50, 0x1f, 0x01 }, // Format: ISP RGB
|
||
new byte[] { 0x44, 0x0e, 0x00 }
|
||
};
|
||
|
||
return await ConfigureRegisters(formatRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置ISP控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureISPControl()
|
||
{
|
||
var ispRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x50, 0x00, 0xA7 }, // ISP控制
|
||
new byte[] { 0x50, 0x01, 0xA3 } // ISP控制
|
||
};
|
||
|
||
return await ConfigureRegisters(ispRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置AEC（自动曝光控制）寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureAEC()
|
||
{
|
||
var aecRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x3a, 0x0f, 0x30 }, // AEC控制;stable range in high
|
||
new byte[] { 0x3a, 0x10, 0x28 }, // AEC控制;stable range in low
|
||
new byte[] { 0x3a, 0x1b, 0x30 }, // AEC控制;stable range out high
|
||
new byte[] { 0x3a, 0x1e, 0x26 }, // AEC控制;stable range out low
|
||
new byte[] { 0x3a, 0x11, 0x60 }, // AEC控制; fast zone high
|
||
new byte[] { 0x3a, 0x1f, 0x14 }, // AEC控制; fast zone low
|
||
new byte[] { 0x3a, 0x02, 0x17 }, // 60Hz max exposure
|
||
new byte[] { 0x3a, 0x03, 0x10 }, // 60Hz max exposure
|
||
new byte[] { 0x3a, 0x14, 0x17 }, // 50Hz max exposure
|
||
new byte[] { 0x3a, 0x15, 0x10 }, // 50Hz max exposure
|
||
new byte[] { 0x3b, 0x07, 0x0a } // 帧曝光模式
|
||
};
|
||
|
||
return await ConfigureRegisters(aecRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置LENC（镜头校正）寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureLENC()
|
||
{
|
||
var lencRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x58, 0x00, 0x23 }, new byte[] { 0x58, 0x01, 0x14 }, new byte[] { 0x58, 0x02, 0x0f },
|
||
new byte[] { 0x58, 0x03, 0x0f }, new byte[] { 0x58, 0x04, 0x12 }, new byte[] { 0x58, 0x05, 0x26 },
|
||
new byte[] { 0x58, 0x06, 0x0c }, new byte[] { 0x58, 0x07, 0x08 }, new byte[] { 0x58, 0x08, 0x05 },
|
||
new byte[] { 0x58, 0x09, 0x05 }, new byte[] { 0x58, 0x0a, 0x08 }, new byte[] { 0x58, 0x0b, 0x0d },
|
||
new byte[] { 0x58, 0x0c, 0x08 }, new byte[] { 0x58, 0x0d, 0x03 }, new byte[] { 0x58, 0x0e, 0x00 },
|
||
new byte[] { 0x58, 0x0f, 0x00 }, new byte[] { 0x58, 0x10, 0x03 }, new byte[] { 0x58, 0x11, 0x09 },
|
||
new byte[] { 0x58, 0x12, 0x07 }, new byte[] { 0x58, 0x13, 0x03 }, new byte[] { 0x58, 0x14, 0x00 },
|
||
new byte[] { 0x58, 0x15, 0x01 }, new byte[] { 0x58, 0x16, 0x03 }, new byte[] { 0x58, 0x17, 0x08 },
|
||
new byte[] { 0x58, 0x18, 0x0d }, new byte[] { 0x58, 0x19, 0x08 }, new byte[] { 0x58, 0x1a, 0x05 },
|
||
new byte[] { 0x58, 0x1b, 0x06 }, new byte[] { 0x58, 0x1c, 0x08 }, new byte[] { 0x58, 0x1d, 0x0e },
|
||
new byte[] { 0x58, 0x1e, 0x29 }, new byte[] { 0x58, 0x1f, 0x17 }, new byte[] { 0x58, 0x20, 0x11 },
|
||
new byte[] { 0x58, 0x21, 0x11 }, new byte[] { 0x58, 0x22, 0x15 }, new byte[] { 0x58, 0x23, 0x28 },
|
||
new byte[] { 0x58, 0x24, 0x46 }, new byte[] { 0x58, 0x25, 0x26 }, new byte[] { 0x58, 0x26, 0x08 },
|
||
new byte[] { 0x58, 0x27, 0x26 }, new byte[] { 0x58, 0x28, 0x64 }, new byte[] { 0x58, 0x29, 0x26 },
|
||
new byte[] { 0x58, 0x2a, 0x24 }, new byte[] { 0x58, 0x2b, 0x22 }, new byte[] { 0x58, 0x2c, 0x24 },
|
||
new byte[] { 0x58, 0x2d, 0x24 }, new byte[] { 0x58, 0x2e, 0x06 }, new byte[] { 0x58, 0x2f, 0x22 },
|
||
new byte[] { 0x58, 0x30, 0x40 }, new byte[] { 0x58, 0x31, 0x42 }, new byte[] { 0x58, 0x32, 0x24 },
|
||
new byte[] { 0x58, 0x33, 0x26 }, new byte[] { 0x58, 0x34, 0x24 }, new byte[] { 0x58, 0x35, 0x22 },
|
||
new byte[] { 0x58, 0x36, 0x22 }, new byte[] { 0x58, 0x37, 0x26 }, new byte[] { 0x58, 0x38, 0x44 },
|
||
new byte[] { 0x58, 0x39, 0x24 }, new byte[] { 0x58, 0x3a, 0x26 }, new byte[] { 0x58, 0x3b, 0x28 },
|
||
new byte[] { 0x58, 0x3c, 0x42 }, new byte[] { 0x58, 0x3d, 0xce }
|
||
};
|
||
|
||
return await ConfigureRegisters(lencRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置摄像头AWB（自动白平衡）寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureAWB()
|
||
{
|
||
var awbRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x51, 0x80, 0xff }, new byte[] { 0x51, 0x81, 0xf2 }, new byte[] { 0x51, 0x82, 0x00 },
|
||
new byte[] { 0x51, 0x83, 0x14 }, new byte[] { 0x51, 0x84, 0x25 }, new byte[] { 0x51, 0x85, 0x24 },
|
||
new byte[] { 0x51, 0x86, 0x09 }, new byte[] { 0x51, 0x87, 0x09 }, new byte[] { 0x51, 0x88, 0x09 },
|
||
new byte[] { 0x51, 0x89, 0x75 }, new byte[] { 0x51, 0x8a, 0x54 }, new byte[] { 0x51, 0x8b, 0xe0 },
|
||
new byte[] { 0x51, 0x8c, 0xb2 }, new byte[] { 0x51, 0x8d, 0x42 }, new byte[] { 0x51, 0x8e, 0x3d },
|
||
new byte[] { 0x51, 0x8f, 0x56 }, new byte[] { 0x51, 0x90, 0x46 }, new byte[] { 0x51, 0x91, 0xf8 },
|
||
new byte[] { 0x51, 0x92, 0x04 }, new byte[] { 0x51, 0x93, 0x70 }, new byte[] { 0x51, 0x94, 0xf0 },
|
||
new byte[] { 0x51, 0x95, 0xf0 }, new byte[] { 0x51, 0x96, 0x03 }, new byte[] { 0x51, 0x97, 0x01 },
|
||
new byte[] { 0x51, 0x98, 0x04 }, new byte[] { 0x51, 0x99, 0x12 }, new byte[] { 0x51, 0x9a, 0x04 },
|
||
new byte[] { 0x51, 0x9b, 0x00 }, new byte[] { 0x51, 0x9c, 0x06 }, new byte[] { 0x51, 0x9d, 0x82 },
|
||
new byte[] { 0x51, 0x9e, 0x38 }
|
||
};
|
||
|
||
return await ConfigureRegisters(awbRegisters, customDelayMs: 2);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置摄像头Gamma校正寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureGamma()
|
||
{
|
||
var gammaRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x54, 0x80, 0x01 }, new byte[] { 0x54, 0x81, 0x08 }, new byte[] { 0x54, 0x82, 0x14 },
|
||
new byte[] { 0x54, 0x83, 0x28 }, new byte[] { 0x54, 0x84, 0x51 }, new byte[] { 0x54, 0x85, 0x65 },
|
||
new byte[] { 0x54, 0x86, 0x71 }, new byte[] { 0x54, 0x87, 0x7d }, new byte[] { 0x54, 0x88, 0x87 },
|
||
new byte[] { 0x54, 0x89, 0x91 }, new byte[] { 0x54, 0x8a, 0x9a }, new byte[] { 0x54, 0x8b, 0xaa },
|
||
new byte[] { 0x54, 0x8c, 0xb8 }, new byte[] { 0x54, 0x8d, 0xcd }, new byte[] { 0x54, 0x8e, 0xdd },
|
||
new byte[] { 0x54, 0x8f, 0xea }, new byte[] { 0x54, 0x90, 0x1d }
|
||
};
|
||
|
||
return await ConfigureRegisters(gammaRegisters);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 配置CMX（色彩矩阵）寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureCMX()
|
||
{
|
||
var cmxRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x53, 0x81, 0x1e }, new byte[] { 0x53, 0x82, 0x5b }, new byte[] { 0x53, 0x83, 0x08 },
|
||
new byte[] { 0x53, 0x84, 0x0a }, new byte[] { 0x53, 0x85, 0x7e }, new byte[] { 0x53, 0x86, 0x88 },
|
||
new byte[] { 0x53, 0x87, 0x7c }, new byte[] { 0x53, 0x88, 0x6c }, new byte[] { 0x53, 0x89, 0x10 },
|
||
new byte[] { 0x53, 0x8a, 0x01 }, new byte[] { 0x53, 0x8b, 0x98 }
|
||
};
|
||
|
||
return await ConfigureRegisters(cmxRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置SDE（特殊数字效果）寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureSDE()
|
||
{
|
||
var sdeRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x55, 0x80, 0x06 }, new byte[] { 0x55, 0x83, 0x40 }, new byte[] { 0x55, 0x84, 0x10 },
|
||
new byte[] { 0x55, 0x89, 0x10 }, new byte[] { 0x55, 0x8a, 0x00 }, new byte[] { 0x55, 0x8b, 0xf8 },
|
||
new byte[] { 0x50, 0x1d, 0x40 }
|
||
};
|
||
|
||
return await ConfigureRegisters(sdeRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置CIP（颜色插值处理）寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureCIP()
|
||
{
|
||
var cipRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x53, 0x00, 0x08 }, new byte[] { 0x53, 0x01, 0x30 }, new byte[] { 0x53, 0x02, 0x10 },
|
||
new byte[] { 0x53, 0x03, 0x00 }, new byte[] { 0x53, 0x04, 0x08 }, new byte[] { 0x53, 0x05, 0x30 },
|
||
new byte[] { 0x53, 0x06, 0x08 }, new byte[] { 0x53, 0x07, 0x16 }, new byte[] { 0x53, 0x09, 0x08 },
|
||
new byte[] { 0x53, 0x0a, 0x30 }, new byte[] { 0x53, 0x0b, 0x04 }, new byte[] { 0x53, 0x0c, 0x06 },
|
||
new byte[] { 0x50, 0x25, 0x00 }
|
||
};
|
||
|
||
return await ConfigureRegisters(cipRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置时序控制寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureTimingControl()
|
||
{
|
||
var timingRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x38, 0x20, 0x46 }, // vflip
|
||
new byte[] { 0x38, 0x21, 0x01 }, // mirror
|
||
new byte[] { 0x38, 0x14, 0x31 }, // timing X inc
|
||
new byte[] { 0x38, 0x15, 0x31 }, // timing Y inc
|
||
new byte[] { 0x36, 0x18, 0x00 },
|
||
new byte[] { 0x36, 0x12, 0x29 },
|
||
new byte[] { 0x37, 0x09, 0x52 },
|
||
new byte[] { 0x37, 0x0c, 0x03 }
|
||
};
|
||
|
||
return await ConfigureRegisters(timingRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配置测试模式和闪光灯寄存器
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> ConfigureTestAndFlash()
|
||
{
|
||
var testRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x40, 0x04, 0x02 }, // BLC(背光) 2 lines
|
||
new byte[] { 0x47, 0x13, 0x03 }, // JPEG mode 3
|
||
new byte[] { 0x44, 0x07, 0x04 }, // 量化标度
|
||
new byte[] { 0x46, 0x0c, 0x20 },
|
||
new byte[] { 0x48, 0x37, 0x22 }, // DVP CLK divider
|
||
new byte[] { 0x38, 0x24, 0x02 }, // DVP CLK divider
|
||
// 彩条测试禁用
|
||
new byte[] { 0x50, 0x3d, 0x00 },
|
||
new byte[] { 0x47, 0x41, 0x00 },
|
||
// 闪光灯配置
|
||
new byte[] { 0x30, 0x16, 0x02 },
|
||
new byte[] { 0x30, 0x1c, 0x02 },
|
||
new byte[] { 0x30, 0x19, 0x02 }, // 开启闪光灯
|
||
new byte[] { 0x30, 0x19, 0x00 } // 关闭闪光灯
|
||
};
|
||
|
||
return await ConfigureRegisters(testRegisters);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 开始流媒体传输
|
||
/// </summary>
|
||
/// <returns>配置结果</returns>
|
||
public async ValueTask<Result<bool>> StartStreaming()
|
||
{
|
||
var startRegisters = new byte[][]
|
||
{
|
||
new byte[] { 0x30, 0x08, 0x02 } // 开始流
|
||
};
|
||
|
||
return await ConfigureRegisters(startRegisters);
|
||
}
|
||
}
|