2173 lines
76 KiB
C#
2173 lines
76 KiB
C#
using System;
|
||
using UnityEngine;
|
||
|
||
namespace BLEProtocol
|
||
{
|
||
/// <summary>
|
||
/// BLE通信协议常量定义
|
||
/// </summary>
|
||
public static class BLEConstants
|
||
{
|
||
// 帧头
|
||
public const byte FRAME_HEADER_1 = 0xAA;
|
||
public const byte FRAME_HEADER_2 = 0x55;
|
||
|
||
// 读/写标识
|
||
public const byte RW_READ = 0x00; // 读操作
|
||
public const byte RW_WRITE = 0x01; // 写操作
|
||
public const byte RW_NOTIFY = 0x02; // 通知
|
||
|
||
// 命令码 - 设备注册与认证类 (0x01-0x0F)
|
||
public const byte CMD_QUERY_REGISTRATION = 0x01; // 查询设备注册状态
|
||
public const byte CMD_DEVICE_REGISTER = 0x02; // 设备注册绑定
|
||
public const byte CMD_USER_LOGIN = 0x03; // 用户登录
|
||
public const byte CMD_FINGERPRINT_ENABLE = 0x04; // 指纹登录使能设置
|
||
public const byte CMD_FINGERPRINT_RECORD = 0x05; // 指纹录制请求
|
||
public const byte CMD_QUERY_USER_LIST = 0x07; // 查询用户列表
|
||
public const byte CMD_UNREGISTER_USER = 0x08; // 注销用户
|
||
|
||
// 通知类型
|
||
public const byte NOTIFY_MOSQUITO_DATA = 0x0B; // 蚊虫数据通知
|
||
|
||
// 命令码 - 设备设置类 (0x10-0x1F)
|
||
public const byte CMD_LANGUAGE_SETTING = 0x10; // 语言设置
|
||
public const byte CMD_TIME_SETTING = 0x11; // 时间设置
|
||
public const byte CMD_SCHEDULE_TASK = 0x12; // 定时任务设置
|
||
|
||
// 命令码 - 外设控制类 (0x20-0x3F)
|
||
public const byte CMD_LCD_SLEEP_SETTING = 0x20; // LCD休眠设置
|
||
public const byte CMD_LCD_BRIGHTNESS_SETTING = 0x21; // LCD亮度设置
|
||
public const byte CMD_RGB_CONTROL = 0x22; // RGB指示灯控制
|
||
public const byte CMD_WIFI_CONTROL = 0x23; // WIFI控制
|
||
public const byte CMD_BLE_CONTROL = 0x24; // BLE控制
|
||
public const byte CMD_MULTIMEDIA_CONTROL = 0x25; // 多媒体控制
|
||
public const byte CMD_FILL_LIGHT_CONTROL = 0x26; // 补光灯控制
|
||
public const byte CMD_FILL_LIGHT_CONNECTION_STATUS = 0x27; // 查询补光灯连接状态
|
||
public const byte CMD_VISIBLE_LASER_CONTROL = 0x28; // 可见光激光器控制
|
||
|
||
// 命令码 - 害虫消灭控制类 (0x40-0x4F)
|
||
public const byte CMD_ANGLE_CONTROL = 0x40; // 角度控制
|
||
public const byte CMD_DISTANCE_CONTROL = 0x41; // 距离控制
|
||
|
||
// 命令码 - 安全设置类 (0x50-0x5F)
|
||
public const byte CMD_MILLIMETER_WAVE_SETTING = 0x50; // 毫米波雷达设置
|
||
public const byte CMD_VISUAL_DETECTION_SETTING = 0x51; // 视觉检测设置
|
||
public const byte CMD_ACCELEROMETER_SETTING = 0x52; // 加速度传感器设置
|
||
public const byte CMD_ACCELEROMETER_DATA = 0x53; // 查询加速度传感器数据
|
||
public const byte CMD_TEMPERATURE_MONITOR_SETTING = 0x55; // 温度监控设置
|
||
public const byte CMD_ENVIRONMENT_CHANGE_TEST = 0x56; // 环境变化检测和试射测试
|
||
|
||
// 命令码 - 设备管理类 (0x60-0x6F)
|
||
public const byte CMD_FACTORY_RESET = 0x60; // 恢复出厂设置
|
||
|
||
// 命令码 - 状态查询类 (0xA0-0xBF)
|
||
public const byte CMD_WORK_MODE_SETTING = 0xA0; // 工作模式设置
|
||
public const byte CMD_HARDWARE_STATUS = 0xA1; // 查询硬件状态
|
||
public const byte CMD_DEVICE_INFO = 0xA2; // 查询设备信息
|
||
public const byte CMD_STATISTICS_DATA = 0xA3; // 查询统计数据
|
||
public const byte CMD_MOSQUITO_DATA_QUERY = 0xA4; // 查询蚊虫数据
|
||
public const byte CMD_SENSOR_DATA = 0xA5; // 查询设备传感器数据
|
||
|
||
// 命令码 - 连接管理类 (0x70-0x7F)
|
||
public const byte CMD_DISCONNECT = 0x70; // 主动断开连接
|
||
|
||
// 命令码 - OTA升级类 (0x80-0x9F)
|
||
public const byte CMD_OTA_QUERY_VERSION = 0x80; // 查询OTA版本信息
|
||
public const byte CMD_OTA_START = 0x81; // 开始升级
|
||
public const byte CMD_OTA_TRANSFER_DATA = 0x82; // 传输固件数据
|
||
public const byte CMD_OTA_END_TRANSFER = 0x83; // 结束传输
|
||
public const byte CMD_OTA_CANCEL = 0x85; // 取消升级
|
||
|
||
// 状态码（0=成功，非0=错误）
|
||
public const byte STATUS_SUCCESS = 0x00; // 成功
|
||
public const byte STATUS_PARAM_ERROR = 0x01; // 参数错误
|
||
public const byte STATUS_PERMISSION_ERROR = 0x02; // 权限错误
|
||
public const byte STATUS_DEVICE_BUSY = 0x03; // 设备忙
|
||
public const byte STATUS_CMD_NOT_SUPPORT = 0x04; // 命令不支持
|
||
public const byte STATUS_DATA_CHECK_FAIL = 0x05; // 数据校验失败
|
||
public const byte STATUS_TIMEOUT = 0x06; // 超时
|
||
public const byte STATUS_DEVICE_ERROR = 0x07; // 设备错误
|
||
|
||
// 最大用户名长度
|
||
public const int MAX_USERNAME_LENGTH = 16;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 通信帧结构
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct BLEFrame
|
||
{
|
||
public byte Header1; // 帧头1: 0xAA
|
||
public byte Header2; // 帧头2: 0x55
|
||
public byte Command; // 命令码
|
||
public byte ReadWrite; // 读/写标识: 0x00=读, 0x01=写, 0x02=通知
|
||
public byte Length; // 数据长度
|
||
public byte[] Data; // 数据字段
|
||
public ushort Crc16; // CRC16校验
|
||
|
||
/// <summary>
|
||
/// 将帧序列化为字节数组
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
int dataLength = Data != null ? Data.Length : 0;
|
||
byte[] bytes = new byte[6 + dataLength + 2]; // 帧头(2) + 命令(1) + 读写(1) + 长度(1) + 数据 + CRC(2)
|
||
|
||
bytes[0] = Header1;
|
||
bytes[1] = Header2;
|
||
bytes[2] = Command;
|
||
bytes[3] = ReadWrite;
|
||
bytes[4] = (byte)dataLength;
|
||
|
||
if (dataLength > 0)
|
||
{
|
||
Buffer.BlockCopy(Data, 0, bytes, 5, dataLength);
|
||
}
|
||
|
||
// 计算CRC16 (帧头到数据字段)
|
||
ushort crc = CRC16.Calculate(bytes, 0, 5 + dataLength);
|
||
bytes[5 + dataLength] = (byte)(crc & 0xFF);
|
||
bytes[6 + dataLength] = (byte)((crc >> 8) & 0xFF);
|
||
|
||
// 调试日志：打印发送的CRC
|
||
UnityEngine.Debug.Log($"[CRC-SEND] 命令=0x{Command:X2}, 数据长度={dataLength}, CRC=0x{crc:X4}, CRC字节={bytes[5 + dataLength]:X2}-{bytes[6 + dataLength]:X2}");
|
||
|
||
return bytes;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 从字节数组解析帧
|
||
/// </summary>
|
||
public static bool TryParse(byte[] bytes, out BLEFrame frame)
|
||
{
|
||
frame = new BLEFrame();
|
||
|
||
if (bytes == null || bytes.Length < 7) // 最小帧长度: 帧头(2) + 命令(1) + 读写(1) + 长度(1) + CRC(2) = 7字节
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 验证帧头
|
||
if (bytes[0] != BLEConstants.FRAME_HEADER_1 || bytes[1] != BLEConstants.FRAME_HEADER_2)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
frame.Header1 = bytes[0];
|
||
frame.Header2 = bytes[1];
|
||
frame.Command = bytes[2];
|
||
frame.ReadWrite = bytes[3];
|
||
frame.Length = bytes[4];
|
||
|
||
int dataLength = frame.Length;
|
||
int expectedLength = 7 + dataLength; // 帧头(2) + 命令(1) + 读写(1) + 长度(1) + 数据(dataLength) + CRC(2)
|
||
if (bytes.Length < expectedLength)
|
||
{
|
||
Debug.LogWarning($"数据长度不足: 需要 {expectedLength} 字节, 实际 {bytes.Length} 字节");
|
||
return false;
|
||
}
|
||
|
||
// 提取数据
|
||
if (dataLength > 0)
|
||
{
|
||
frame.Data = new byte[dataLength];
|
||
Buffer.BlockCopy(bytes, 5, frame.Data, 0, dataLength);
|
||
}
|
||
|
||
// 提取CRC
|
||
frame.Crc16 = (ushort)(bytes[5 + dataLength] | (bytes[6 + dataLength] << 8));
|
||
|
||
// 验证CRC
|
||
ushort calculatedCrc = CRC16.Calculate(bytes, 0, 5 + dataLength);
|
||
Debug.Log($"[CRC调试] 计算值={calculatedCrc:X4}, 接收值={frame.Crc16:X4}");
|
||
Debug.Log($"[CRC调试] 计算数据: {System.BitConverter.ToString(bytes, 0, 5 + dataLength)}");
|
||
Debug.Log($"[CRC调试] 接收CRC字节: {bytes[5 + dataLength]:X2}-{bytes[6 + dataLength]:X2}");
|
||
if (calculatedCrc != frame.Crc16)
|
||
{
|
||
Debug.LogWarning($"CRC校验失败: 计算值={calculatedCrc:X4} ({calculatedCrc & 0xFF:X2}-{(calculatedCrc >> 8) & 0xFF:X2}), 接收值={frame.Crc16:X4} ({frame.Crc16 & 0xFF:X2}-{(frame.Crc16 >> 8) & 0xFF:X2})");
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设备注册状态响应
|
||
/// 命令 0x01 返回：
|
||
/// - 文档标准：1字节（0x00=未注册, 0x01=已注册）
|
||
/// - 当前固件：2字节（00-01，第一位状态码，第二位注册状态）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct DeviceRegistrationStatus
|
||
{
|
||
public byte Status; // 响应状态码（0x00=成功）
|
||
public byte RegistrationState; // 0x00=否/未注册, 0x01=是/已注册
|
||
|
||
/// <summary>
|
||
/// 从数据字节解析
|
||
/// 兼容1字节和2字节格式
|
||
/// </summary>
|
||
public static DeviceRegistrationStatus FromBytes(byte[] data)
|
||
{
|
||
var status = new DeviceRegistrationStatus();
|
||
if (data == null || data.Length == 0)
|
||
return status;
|
||
|
||
if (data.Length == 1)
|
||
{
|
||
// 标准格式：1字节，直接是注册状态
|
||
status.Status = 0x00; // 假设成功
|
||
status.RegistrationState = data[0];
|
||
}
|
||
else if (data.Length >= 2)
|
||
{
|
||
// 当前固件格式：2字节（00-01）
|
||
status.Status = data[0]; // 第一位：状态码
|
||
status.RegistrationState = data[1]; // 第二位：注册状态
|
||
}
|
||
return status;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是否已注册（0=否，1=是）
|
||
/// </summary>
|
||
public bool IsRegistered => RegistrationState == 0x01;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设备注册请求
|
||
/// 注意：根据协议，只发送用户名，不发送密码
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct DeviceRegisterRequest
|
||
{
|
||
public string Username; // 用户名 (最多16字节ASCII)
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组
|
||
/// 只发送用户名（16字节），不发送密码
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] bytes = new byte[16]; // 仅用户名(16字节)
|
||
|
||
// 用户名 (16字节, 不足补0)
|
||
byte[] usernameBytes = System.Text.Encoding.ASCII.GetBytes(Username ?? "");
|
||
int usernameLen = System.Math.Min(usernameBytes.Length, 16);
|
||
System.Buffer.BlockCopy(usernameBytes, 0, bytes, 0, usernameLen);
|
||
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 注销用户请求
|
||
/// 命令 0x08：注销指定用户
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct UnregisterUserRequest
|
||
{
|
||
public string Username; // 要注销的用户名 (最多16字节ASCII)
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组
|
||
/// 用户名（16字节，不足补0）
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] bytes = new byte[16]; // 用户名(16字节)
|
||
|
||
// 用户名 (16字节, 不足补0)
|
||
byte[] usernameBytes = System.Text.Encoding.ASCII.GetBytes(Username ?? "");
|
||
int usernameLen = System.Math.Min(usernameBytes.Length, 16);
|
||
System.Buffer.BlockCopy(usernameBytes, 0, bytes, 0, usernameLen);
|
||
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 注销用户响应
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct UnregisterUserResponse
|
||
{
|
||
public byte Status; // 响应状态码（0x00=成功）
|
||
|
||
/// <summary>
|
||
/// 是否成功
|
||
/// </summary>
|
||
public bool IsSuccess => Status == 0x00;
|
||
|
||
/// <summary>
|
||
/// 从数据字节解析
|
||
/// </summary>
|
||
public static UnregisterUserResponse FromBytes(byte status)
|
||
{
|
||
return new UnregisterUserResponse { Status = status };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 用户登录请求
|
||
/// 命令 0x03：用户登录（密码）
|
||
/// 数据格式：用户名(16字节) + 解锁状态(1字节)，解锁状态固定为1
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct UserLoginRequest
|
||
{
|
||
public string Username; // 用户名 (最多16字节ASCII)
|
||
public byte UnlockStatus; // 解锁状态，固定为1
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组
|
||
/// 用户名（16字节，不足补0）+ 解锁状态（1字节，固定为1）
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] bytes = new byte[17]; // 用户名(16字节) + 解锁状态(1字节)
|
||
|
||
// 用户名 (16字节, 不足补0)
|
||
byte[] usernameBytes = System.Text.Encoding.ASCII.GetBytes(Username ?? "");
|
||
int usernameLen = System.Math.Min(usernameBytes.Length, 16);
|
||
System.Buffer.BlockCopy(usernameBytes, 0, bytes, 0, usernameLen);
|
||
|
||
// 解锁状态固定为1
|
||
bytes[16] = 0x01;
|
||
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 用户登录响应
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct UserLoginResponse
|
||
{
|
||
public byte Status; // 响应状态码（0x00=成功）
|
||
|
||
/// <summary>
|
||
/// 是否成功
|
||
/// </summary>
|
||
public bool IsSuccess => Status == 0x00;
|
||
|
||
/// <summary>
|
||
/// 从数据字节解析
|
||
/// </summary>
|
||
public static UserLoginResponse FromBytes(byte status)
|
||
{
|
||
return new UserLoginResponse { Status = status };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指纹登录使能设置请求
|
||
/// 命令 0x04：设置用户指纹登录使能状态
|
||
/// 数据格式：用户名(16字节) + 使能状态(1字节)
|
||
/// 使能状态：0x00=禁用, 0x01=使能
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct FingerprintEnableRequest
|
||
{
|
||
public string Username; // 用户名 (最多16字节ASCII)
|
||
public bool Enable; // 使能状态：true=使能, false=禁用
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组
|
||
/// 用户名（16字节，不足补0）+ 使能状态（1字节）
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] bytes = new byte[17]; // 用户名(16字节) + 使能状态(1字节)
|
||
|
||
// 用户名 (16字节, 不足补0)
|
||
byte[] usernameBytes = System.Text.Encoding.ASCII.GetBytes(Username ?? "");
|
||
int usernameLen = System.Math.Min(usernameBytes.Length, 16);
|
||
System.Buffer.BlockCopy(usernameBytes, 0, bytes, 0, usernameLen);
|
||
|
||
// 使能状态
|
||
bytes[16] = Enable ? (byte)0x01 : (byte)0x00;
|
||
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指纹登录使能设置响应
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct FingerprintEnableResponse
|
||
{
|
||
public byte Status; // 响应状态码（0x00=成功）
|
||
|
||
/// <summary>
|
||
/// 是否成功
|
||
/// </summary>
|
||
public bool IsSuccess => Status == 0x00;
|
||
|
||
/// <summary>
|
||
/// 从数据字节解析
|
||
/// </summary>
|
||
public static FingerprintEnableResponse FromBytes(byte status)
|
||
{
|
||
return new FingerprintEnableResponse { Status = status };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指纹录制请求
|
||
/// 命令 0x05：启动指纹注册流程
|
||
/// 数据格式：用户名(16字节)
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct FingerprintRecordRequest
|
||
{
|
||
public string Username; // 用户名 (最多16字节ASCII)
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组
|
||
/// 用户名（16字节，不足补0）
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] bytes = new byte[16]; // 用户名(16字节)
|
||
|
||
// 用户名 (16字节, 不足补0)
|
||
byte[] usernameBytes = System.Text.Encoding.ASCII.GetBytes(Username ?? "");
|
||
int usernameLen = System.Math.Min(usernameBytes.Length, 16);
|
||
System.Buffer.BlockCopy(usernameBytes, 0, bytes, 0, usernameLen);
|
||
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指纹录制响应
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct FingerprintRecordResponse
|
||
{
|
||
public byte Status; // 响应状态码（0x00=成功）
|
||
|
||
/// <summary>
|
||
/// 是否成功
|
||
/// </summary>
|
||
public bool IsSuccess => Status == 0x00;
|
||
|
||
/// <summary>
|
||
/// 从数据字节解析
|
||
/// </summary>
|
||
public static FingerprintRecordResponse FromBytes(byte status)
|
||
{
|
||
return new FingerprintRecordResponse { Status = status };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 通用响应结构
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct BLEResponse
|
||
{
|
||
public byte Status; // 状态码（0=成功，其他=错误码）
|
||
public byte[] Data; // 响应数据
|
||
|
||
/// <summary>
|
||
/// 是否成功（状态码0=成功，非0=失败）
|
||
/// </summary>
|
||
public bool IsSuccess => Status == 0x00;
|
||
|
||
public static BLEResponse FromFrame(BLEFrame frame)
|
||
{
|
||
var response = new BLEResponse();
|
||
if (frame.Data != null && frame.Data.Length > 0)
|
||
{
|
||
response.Status = frame.Data[0];
|
||
// 兼容返回2字节的情况，取剩余字节作为数据
|
||
if (frame.Data.Length > 1)
|
||
{
|
||
response.Data = new byte[frame.Data.Length - 1];
|
||
System.Buffer.BlockCopy(frame.Data, 1, response.Data, 0, frame.Data.Length - 1);
|
||
}
|
||
}
|
||
return response;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 用户信息
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct UserInfo
|
||
{
|
||
public string Username; // 用户名
|
||
public byte FingerprintId; // 指纹ID
|
||
public bool HasFingerprint; // 是否有指纹
|
||
}
|
||
|
||
/// <summary>
|
||
/// 用户列表响应
|
||
/// 命令 0x07 返回：
|
||
/// - 文档标准：用户数量(1字节) + 每个用户：用户名(16字节) + 指纹ID(1字节) + 指纹ID有效标志(1字节)
|
||
/// - 当前固件：用户数量(2字节，低字节在前) + 每个用户信息
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct UserListResponse
|
||
{
|
||
public byte Status; // 响应状态码（0x00=成功）
|
||
public ushort UserCount; // 用户数量（兼容1字节和2字节）
|
||
public UserInfo[] Users; // 用户列表
|
||
|
||
/// <summary>
|
||
/// 从数据字节解析
|
||
/// 数据格式（不包含状态码，因为BLEResponse已经提取了）：
|
||
/// - 标准格式：用户数量(1) + [用户名(16) + 指纹ID(1) + 指纹有效标志(1)] * N
|
||
/// - 当前固件：用户数量(2) + [用户名(16) + 指纹ID(1) + 指纹有效标志(1)] * N
|
||
/// </summary>
|
||
/// <param name="status">响应状态码</param>
|
||
/// <param name="data">数据内容（不包含状态码）</param>
|
||
public static UserListResponse FromBytes(byte status, byte[] data)
|
||
{
|
||
var response = new UserListResponse();
|
||
response.Status = status;
|
||
if (data == null || data.Length < 1)
|
||
return response;
|
||
|
||
// 注意：传入的data不包含状态码，因为BLEResponse.FromFrame已经提取了
|
||
// 判断用户数量是1字节还是2字节
|
||
int userSize = 16 + 1 + 1; // 用户名(16) + 指纹ID(1) + 指纹有效标志(1) = 18字节
|
||
|
||
// 尝试按1字节解析
|
||
byte userCount1Byte = data[0];
|
||
int expectedLen1Byte = 1 + userCount1Byte * userSize;
|
||
|
||
// 尝试按2字节解析（小端序）
|
||
ushort userCount2Byte = 0;
|
||
if (data.Length >= 2)
|
||
{
|
||
userCount2Byte = (ushort)(data[0] | (data[1] << 8));
|
||
}
|
||
int expectedLen2Byte = 2 + userCount2Byte * userSize;
|
||
|
||
int offset;
|
||
if (data.Length == expectedLen1Byte)
|
||
{
|
||
// 1字节格式
|
||
response.UserCount = userCount1Byte;
|
||
offset = 1;
|
||
}
|
||
else if (data.Length == expectedLen2Byte)
|
||
{
|
||
// 2字节格式
|
||
response.UserCount = userCount2Byte;
|
||
offset = 2;
|
||
}
|
||
else
|
||
{
|
||
// 默认按1字节解析
|
||
response.UserCount = userCount1Byte;
|
||
offset = 1;
|
||
}
|
||
|
||
if (response.UserCount == 0 || data.Length < offset + response.UserCount * userSize)
|
||
{
|
||
response.Users = new UserInfo[0];
|
||
return response;
|
||
}
|
||
|
||
response.Users = new UserInfo[response.UserCount];
|
||
|
||
for (int i = 0; i < response.UserCount; i++)
|
||
{
|
||
// 用户名 (16字节)
|
||
byte[] usernameBytes = new byte[16];
|
||
Buffer.BlockCopy(data, offset, usernameBytes, 0, 16);
|
||
// 去除末尾的0字节
|
||
int nameLen = 0;
|
||
while (nameLen < 16 && usernameBytes[nameLen] != 0)
|
||
nameLen++;
|
||
response.Users[i].Username = System.Text.Encoding.ASCII.GetString(usernameBytes, 0, nameLen);
|
||
offset += 16;
|
||
|
||
// 指纹ID
|
||
response.Users[i].FingerprintId = data[offset++];
|
||
|
||
// 指纹ID有效标志
|
||
response.Users[i].HasFingerprint = data[offset++] == 0x01;
|
||
}
|
||
|
||
return response;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 是否成功
|
||
/// </summary>
|
||
public bool IsSuccess => Status == 0x00;
|
||
}
|
||
|
||
#region 设备设置类结构体 (0x10-0x1F)
|
||
|
||
/// <summary>
|
||
/// 语言设置
|
||
/// 命令 0x10：0x00=英文, 0x01=中文
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct LanguageSetting
|
||
{
|
||
public byte Language; // 0x00=英文, 0x01=中文
|
||
|
||
public bool IsChinese => Language == 0x01;
|
||
public bool IsEnglish => Language == 0x00;
|
||
|
||
public static LanguageSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new LanguageSetting();
|
||
if (data != null && data.Length > 0)
|
||
{
|
||
setting.Language = data[0];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { Language };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 时间设置
|
||
/// 命令 0x11：年(1) + 月(1) + 日(1) + 时(1) + 分(1) + 秒(1)
|
||
/// 年：相对于2000年的偏移（0-255对应2000-2255年）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct TimeSetting
|
||
{
|
||
public byte Year; // 相对于2000年的偏移
|
||
public byte Month; // 1-12
|
||
public byte Day; // 1-31
|
||
public byte Hour; // 0-23
|
||
public byte Minute; // 0-59
|
||
public byte Second; // 0-59
|
||
|
||
public int ActualYear => 2000 + Year;
|
||
|
||
public static TimeSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new TimeSetting();
|
||
if (data != null && data.Length >= 6)
|
||
{
|
||
setting.Year = data[0];
|
||
setting.Month = data[1];
|
||
setting.Day = data[2];
|
||
setting.Hour = data[3];
|
||
setting.Minute = data[4];
|
||
setting.Second = data[5];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { Year, Month, Day, Hour, Minute, Second };
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"{ActualYear}-{Month:D2}-{Day:D2} {Hour:D2}:{Minute:D2}:{Second:D2}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 定时任务模式
|
||
/// </summary>
|
||
public enum ScheduleTaskMode : byte
|
||
{
|
||
Standby = 0x00, // 待机（用于定时关机）
|
||
Scan = 0x01, // 扫描
|
||
Sterilize = 0x02 // 消杀
|
||
}
|
||
|
||
/// <summary>
|
||
/// 定时任务
|
||
/// 命令 0x12：任务ID(1) + 开关(1) + 开始小时(1) + 开始分钟(1) + 结束小时(1) + 结束分钟(1) + 模式(1) + 重复(1)
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct ScheduleTask
|
||
{
|
||
public byte TaskId; // 任务ID：0-4
|
||
public bool Enabled; // 开关：true=启用, false=禁用
|
||
public byte StartHour; // 开始小时：0-23
|
||
public byte StartMinute; // 开始分钟：0-59
|
||
public byte EndHour; // 结束小时：0-23
|
||
public byte EndMinute; // 结束分钟：0-59
|
||
public ScheduleTaskMode Mode; // 模式
|
||
public byte Repeat; // 重复：按位表示星期几
|
||
|
||
// 重复位定义
|
||
public const byte REPEAT_MONDAY = 0x01;
|
||
public const byte REPEAT_TUESDAY = 0x02;
|
||
public const byte REPEAT_WEDNESDAY = 0x04;
|
||
public const byte REPEAT_THURSDAY = 0x08;
|
||
public const byte REPEAT_FRIDAY = 0x10;
|
||
public const byte REPEAT_SATURDAY = 0x20;
|
||
public const byte REPEAT_SUNDAY = 0x40;
|
||
|
||
/// <summary>
|
||
/// 从字节数组解析（写入格式，包含TaskId，8字节）
|
||
/// 格式：任务ID(1) + 开关(1) + 开始小时(1) + 开始分钟(1) + 结束小时(1) + 结束分钟(1) + 模式(1) + 重复(1)
|
||
/// </summary>
|
||
public static ScheduleTask FromBytes(byte[] data, int offset = 0)
|
||
{
|
||
var task = new ScheduleTask();
|
||
if (data != null && data.Length >= offset + 8)
|
||
{
|
||
task.TaskId = data[offset];
|
||
task.Enabled = data[offset + 1] == 0x01;
|
||
task.StartHour = data[offset + 2];
|
||
task.StartMinute = data[offset + 3];
|
||
task.EndHour = data[offset + 4];
|
||
task.EndMinute = data[offset + 5];
|
||
task.Mode = (ScheduleTaskMode)data[offset + 6];
|
||
task.Repeat = data[offset + 7];
|
||
}
|
||
return task;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 从字节数组解析（读取格式，不包含TaskId，7字节）
|
||
/// 格式：开关(1) + 开始小时(1) + 开始分钟(1) + 结束小时(1) + 结束分钟(1) + 模式(1) + 重复(1)
|
||
/// </summary>
|
||
public static ScheduleTask FromBytesRead(byte[] data, int offset, byte taskId)
|
||
{
|
||
var task = new ScheduleTask();
|
||
if (data != null && data.Length >= offset + 7)
|
||
{
|
||
task.TaskId = taskId; // 读取时TaskId从数组索引推断
|
||
task.Enabled = data[offset] == 0x01;
|
||
task.StartHour = data[offset + 1];
|
||
task.StartMinute = data[offset + 2];
|
||
task.EndHour = data[offset + 3];
|
||
task.EndMinute = data[offset + 4];
|
||
task.Mode = (ScheduleTaskMode)data[offset + 5];
|
||
task.Repeat = data[offset + 6];
|
||
}
|
||
return task;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
TaskId,
|
||
Enabled ? (byte)0x01 : (byte)0x00,
|
||
StartHour,
|
||
StartMinute,
|
||
EndHour,
|
||
EndMinute,
|
||
(byte)Mode,
|
||
Repeat
|
||
};
|
||
}
|
||
|
||
public bool IsRepeatMonday => (Repeat & REPEAT_MONDAY) != 0;
|
||
public bool IsRepeatTuesday => (Repeat & REPEAT_TUESDAY) != 0;
|
||
public bool IsRepeatWednesday => (Repeat & REPEAT_WEDNESDAY) != 0;
|
||
public bool IsRepeatThursday => (Repeat & REPEAT_THURSDAY) != 0;
|
||
public bool IsRepeatFriday => (Repeat & REPEAT_FRIDAY) != 0;
|
||
public bool IsRepeatSaturday => (Repeat & REPEAT_SATURDAY) != 0;
|
||
public bool IsRepeatSunday => (Repeat & REPEAT_SUNDAY) != 0;
|
||
|
||
public string GetRepeatString()
|
||
{
|
||
if (Repeat == 0) return "不重复";
|
||
var days = new System.Collections.Generic.List<string>();
|
||
if (IsRepeatMonday) days.Add("周一");
|
||
if (IsRepeatTuesday) days.Add("周二");
|
||
if (IsRepeatWednesday) days.Add("周三");
|
||
if (IsRepeatThursday) days.Add("周四");
|
||
if (IsRepeatFriday) days.Add("周五");
|
||
if (IsRepeatSaturday) days.Add("周六");
|
||
if (IsRepeatSunday) days.Add("周日");
|
||
return string.Join(",", days);
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
string modeStr = Mode switch
|
||
{
|
||
ScheduleTaskMode.Standby => "待机",
|
||
ScheduleTaskMode.Scan => "扫描",
|
||
ScheduleTaskMode.Sterilize => "消杀",
|
||
_ => "未知"
|
||
};
|
||
return $"任务{TaskId}: {(Enabled ? "启用" : "禁用")} {StartHour:D2}:{StartMinute:D2}-{EndHour:D2}:{EndMinute:D2} {modeStr} [{GetRepeatString()}]";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 定时任务列表响应
|
||
/// 读取返回格式：每个任务7字节（不包含TaskId）
|
||
/// 开关(1) + 开始小时(1) + 开始分钟(1) + 结束小时(1) + 结束分钟(1) + 模式(1) + 重复(1)
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct ScheduleTaskListResponse
|
||
{
|
||
public byte Status; // 响应状态码
|
||
public ScheduleTask[] Tasks; // 定时任务列表
|
||
|
||
public static ScheduleTaskListResponse FromBytes(byte status, byte[] data)
|
||
{
|
||
var response = new ScheduleTaskListResponse();
|
||
response.Status = status;
|
||
if (data == null || data.Length < 7)
|
||
{
|
||
response.Tasks = new ScheduleTask[0];
|
||
return response;
|
||
}
|
||
|
||
int taskCount = data.Length / 7; // 每个任务7字节（不包含TaskId）
|
||
response.Tasks = new ScheduleTask[taskCount];
|
||
for (int i = 0; i < taskCount; i++)
|
||
{
|
||
response.Tasks[i] = ScheduleTask.FromBytesRead(data, i * 7, (byte)i);
|
||
}
|
||
return response;
|
||
}
|
||
|
||
public bool IsSuccess => Status == 0x00;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 外设控制类结构体 (0x20-0x3F)
|
||
|
||
/// <summary>
|
||
/// LCD休眠设置
|
||
/// 命令 0x20：休眠开关(1) + 休眠时间(1)
|
||
/// 休眠开关：0x00=关闭，0x01=开启
|
||
/// 休眠时间：0x01=1分钟，0x05=5分钟，0x0A=10分钟，0x1E=30分钟
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct LCDSleepSetting
|
||
{
|
||
public bool Enable; // 休眠开关
|
||
public byte SleepTime; // 休眠时间
|
||
|
||
public static LCDSleepSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new LCDSleepSetting();
|
||
if (data != null && data.Length >= 2)
|
||
{
|
||
setting.Enable = data[0] == 0x01;
|
||
setting.SleepTime = data[1];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { Enable ? (byte)0x01 : (byte)0x00, SleepTime };
|
||
}
|
||
|
||
public string GetSleepTimeString()
|
||
{
|
||
return SleepTime switch
|
||
{
|
||
0x01 => "1分钟",
|
||
0x05 => "5分钟",
|
||
0x0A => "10分钟",
|
||
0x1E => "30分钟",
|
||
_ => "未知"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// LCD亮度设置
|
||
/// 命令 0x21：自适应开关(1) + 亮度值(1)
|
||
/// 自适应开关：0x00=关闭，0x01=开启
|
||
/// 亮度值：10-100%（仅在自适应关闭时有效）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct LCDBrightnessSetting
|
||
{
|
||
public bool AutoBrightness; // 自适应开关
|
||
public byte Brightness; // 亮度值（10-100%）
|
||
|
||
public static LCDBrightnessSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new LCDBrightnessSetting();
|
||
if (data != null && data.Length >= 2)
|
||
{
|
||
setting.AutoBrightness = data[0] == 0x01;
|
||
setting.Brightness = data[1];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { AutoBrightness ? (byte)0x01 : (byte)0x00, Brightness };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// RGB指示灯效果模式
|
||
/// </summary>
|
||
public enum RGBEffectMode : byte
|
||
{
|
||
Off = 0x00, // 关闭
|
||
Solid = 0x01, // 常亮
|
||
Blinking = 0x02, // 闪烁
|
||
Warning = 0x03 // 警示
|
||
}
|
||
|
||
/// <summary>
|
||
/// RGB指示灯控制
|
||
/// 命令 0x22：开关(1) + 红色(1) + 绿色(1) + 蓝色(1) + 效果模式(1)
|
||
/// 开关：0x00=关闭，0x01=开启
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct RGBControl
|
||
{
|
||
public bool Enable; // 开关
|
||
public byte Red; // 红色值（0-255）
|
||
public byte Green; // 绿色值（0-255）
|
||
public byte Blue; // 蓝色值（0-255）
|
||
public RGBEffectMode Effect; // 效果模式
|
||
|
||
public static RGBControl FromBytes(byte[] data)
|
||
{
|
||
var control = new RGBControl();
|
||
if (data == null || data.Length == 0)
|
||
return control;
|
||
|
||
// 兼容不同格式的数据返回
|
||
// 完整格式: 开关(1) + R(1) + G(1) + B(1) + 效果(1) = 5字节
|
||
// 简化格式: R(1) + G(1) + B(1) = 3字节 (没有状态码前缀的情况)
|
||
// 带状态码: 状态码(1) + [开关 +] R + G + B [+ 效果]
|
||
|
||
int offset = 0;
|
||
|
||
// 如果数据长度大于3且第一个字节是0或1，可能是开关字节
|
||
if (data.Length >= 5)
|
||
{
|
||
// 完整格式: 开关 + R + G + B + 效果
|
||
control.Enable = data[0] == 0x01;
|
||
control.Red = data[1];
|
||
control.Green = data[2];
|
||
control.Blue = data[3];
|
||
control.Effect = (RGBEffectMode)data[4];
|
||
}
|
||
else if (data.Length >= 4)
|
||
{
|
||
// 可能是: 开关 + R + G + B (无效果模式)
|
||
control.Enable = data[0] == 0x01;
|
||
control.Red = data[1];
|
||
control.Green = data[2];
|
||
control.Blue = data[3];
|
||
}
|
||
else if (data.Length >= 3)
|
||
{
|
||
// 简化格式: 只有 R + G + B
|
||
control.Enable = true; // 默认开启
|
||
control.Red = data[0];
|
||
control.Green = data[1];
|
||
control.Blue = data[2];
|
||
}
|
||
|
||
return control;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
Enable ? (byte)0x01 : (byte)0x00,
|
||
Red,
|
||
Green,
|
||
Blue,
|
||
(byte)Effect
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// WIFI控制
|
||
/// 命令 0x23：
|
||
/// 读操作：返回65字节（开关1字节 + SSID 32字节 + 密码32字节）
|
||
/// 写操作：可变长度，至少1字节（开关），可选包含SSID和密码
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct WIFIControl
|
||
{
|
||
public bool Enable; // 开关
|
||
public string SSID; // SSID
|
||
public string Password; // 密码
|
||
|
||
public static WIFIControl FromBytes(byte[] data)
|
||
{
|
||
var control = new WIFIControl();
|
||
if (data != null && data.Length >= 1)
|
||
{
|
||
control.Enable = data[0] == 0x01;
|
||
if (data.Length >= 33)
|
||
{
|
||
// SSID (32字节)
|
||
byte[] ssidBytes = new byte[32];
|
||
Buffer.BlockCopy(data, 1, ssidBytes, 0, 32);
|
||
int ssidLen = 0;
|
||
while (ssidLen < 32 && ssidBytes[ssidLen] != 0)
|
||
ssidLen++;
|
||
control.SSID = System.Text.Encoding.ASCII.GetString(ssidBytes, 0, ssidLen);
|
||
}
|
||
if (data.Length >= 65)
|
||
{
|
||
// 密码 (32字节)
|
||
byte[] passwordBytes = new byte[32];
|
||
Buffer.BlockCopy(data, 33, passwordBytes, 0, 32);
|
||
int passwordLen = 0;
|
||
while (passwordLen < 32 && passwordBytes[passwordLen] != 0)
|
||
passwordLen++;
|
||
control.Password = System.Text.Encoding.ASCII.GetString(passwordBytes, 0, passwordLen);
|
||
}
|
||
}
|
||
return control;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
// 计算长度：至少1字节（开关）
|
||
int length = 1;
|
||
if (!string.IsNullOrEmpty(SSID))
|
||
length += SSID.Length + 1; // SSID + 结束符
|
||
if (!string.IsNullOrEmpty(Password))
|
||
length += Password.Length + 1; // 密码 + 结束符
|
||
|
||
byte[] bytes = new byte[length];
|
||
bytes[0] = Enable ? (byte)0x01 : (byte)0x00;
|
||
int offset = 1;
|
||
|
||
if (!string.IsNullOrEmpty(SSID))
|
||
{
|
||
byte[] ssidBytes = System.Text.Encoding.ASCII.GetBytes(SSID);
|
||
int ssidLen = System.Math.Min(ssidBytes.Length, 32);
|
||
Buffer.BlockCopy(ssidBytes, 0, bytes, offset, ssidLen);
|
||
offset += ssidLen;
|
||
bytes[offset++] = 0; // 结束符
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(Password))
|
||
{
|
||
byte[] passwordBytes = System.Text.Encoding.ASCII.GetBytes(Password);
|
||
int passwordLen = System.Math.Min(passwordBytes.Length, 32);
|
||
Buffer.BlockCopy(passwordBytes, 0, bytes, offset, passwordLen);
|
||
offset += passwordLen;
|
||
bytes[offset++] = 0; // 结束符
|
||
}
|
||
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// BLE控制
|
||
/// 命令 0x24：设置BLE广播名称
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct BLEControl
|
||
{
|
||
public string DeviceName; // 设备名称
|
||
|
||
public static BLEControl FromBytes(byte[] data)
|
||
{
|
||
var control = new BLEControl();
|
||
if (data != null && data.Length > 0)
|
||
{
|
||
// 去除末尾的0字节
|
||
int nameLen = 0;
|
||
while (nameLen < data.Length && data[nameLen] != 0)
|
||
nameLen++;
|
||
control.DeviceName = System.Text.Encoding.ASCII.GetString(data, 0, nameLen);
|
||
}
|
||
return control;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] nameBytes = System.Text.Encoding.ASCII.GetBytes(DeviceName ?? "");
|
||
byte[] bytes = new byte[nameBytes.Length + 1]; // 名称 + 结束符
|
||
Buffer.BlockCopy(nameBytes, 0, bytes, 0, nameBytes.Length);
|
||
bytes[nameBytes.Length] = 0; // 结束符
|
||
return bytes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 音效类型
|
||
/// </summary>
|
||
public enum SoundEffectType : byte
|
||
{
|
||
Hello = 0x00, // Hello音效
|
||
Goodbye = 0x01, // Goodbye音效
|
||
Test = 0x02, // Test音效
|
||
BIU = 0x03, // BIU音效
|
||
Main = 0x04 // Main音效
|
||
}
|
||
|
||
/// <summary>
|
||
/// 多媒体控制
|
||
/// 命令 0x25：
|
||
/// 读操作：返回5字节（视频录制开关1 + 录制时长1 + 音效开关1 + 音效类型1 + 音量1）
|
||
/// 写操作：可变长度，至少1字节（视频录制开关）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct MultimediaControl
|
||
{
|
||
public bool VideoRecordEnable; // 视频录制开关
|
||
public byte RecordDuration; // 录制时长（0x03=3秒, 0x05=5秒, 0x0A=10秒）
|
||
public bool SoundEnable; // 音效开关
|
||
public SoundEffectType SoundType; // 音效类型
|
||
public byte Volume; // 音量（0-15）
|
||
|
||
public static MultimediaControl FromBytes(byte[] data)
|
||
{
|
||
var control = new MultimediaControl();
|
||
if (data != null && data.Length >= 1)
|
||
{
|
||
control.VideoRecordEnable = data[0] == 0x01;
|
||
if (data.Length >= 2)
|
||
control.RecordDuration = data[1];
|
||
if (data.Length >= 3)
|
||
control.SoundEnable = data[2] == 0x01;
|
||
if (data.Length >= 4)
|
||
control.SoundType = (SoundEffectType)data[3];
|
||
if (data.Length >= 5)
|
||
control.Volume = data[4];
|
||
}
|
||
return control;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
// 可变长度，至少1字节
|
||
byte[] bytes = new byte[5]; // 完整数据
|
||
bytes[0] = VideoRecordEnable ? (byte)0x01 : (byte)0x00;
|
||
bytes[1] = RecordDuration;
|
||
bytes[2] = SoundEnable ? (byte)0x01 : (byte)0x00;
|
||
bytes[3] = (byte)SoundType;
|
||
bytes[4] = Volume;
|
||
return bytes;
|
||
}
|
||
|
||
public string GetDurationString()
|
||
{
|
||
return RecordDuration switch
|
||
{
|
||
0x03 => "3秒",
|
||
0x05 => "5秒",
|
||
0x0A => "10秒",
|
||
_ => "未知"
|
||
};
|
||
}
|
||
|
||
public string GetSoundTypeString()
|
||
{
|
||
return SoundType switch
|
||
{
|
||
SoundEffectType.Hello => "Hello",
|
||
SoundEffectType.Goodbye => "Goodbye",
|
||
SoundEffectType.Test => "Test",
|
||
SoundEffectType.BIU => "BIU",
|
||
SoundEffectType.Main => "Main",
|
||
_ => "未知"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 补光类型
|
||
/// </summary>
|
||
public enum FillLightType : byte
|
||
{
|
||
Infrared = 0x00, // 红外光
|
||
White = 0x01 // 白光
|
||
}
|
||
|
||
/// <summary>
|
||
/// 光照强度
|
||
/// </summary>
|
||
public enum LightIntensity : byte
|
||
{
|
||
Low = 0x00, // 低
|
||
Medium = 0x01, // 中
|
||
High = 0x02 // 高
|
||
}
|
||
|
||
/// <summary>
|
||
/// 补光灯控制
|
||
/// 命令 0x26：开关(1) + 补光类型(1) + 光照强度(1)
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct FillLightControl
|
||
{
|
||
public bool Enable; // 开关
|
||
public FillLightType LightType; // 补光类型
|
||
public LightIntensity Intensity; // 光照强度
|
||
|
||
public static FillLightControl FromBytes(byte[] data)
|
||
{
|
||
var control = new FillLightControl();
|
||
if (data != null && data.Length >= 3)
|
||
{
|
||
control.Enable = data[0] == 0x01;
|
||
control.LightType = (FillLightType)data[1];
|
||
control.Intensity = (LightIntensity)data[2];
|
||
}
|
||
return control;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
Enable ? (byte)0x01 : (byte)0x00,
|
||
(byte)LightType,
|
||
(byte)Intensity
|
||
};
|
||
}
|
||
|
||
public string GetLightTypeString()
|
||
{
|
||
return LightType == FillLightType.Infrared ? "红外光" : "白光";
|
||
}
|
||
|
||
public string GetIntensityString()
|
||
{
|
||
return Intensity switch
|
||
{
|
||
LightIntensity.Low => "低",
|
||
LightIntensity.Medium => "中",
|
||
LightIntensity.High => "高",
|
||
_ => "未知"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 补光灯连接状态
|
||
/// 命令 0x27：返回连接状态(1字节)
|
||
/// 0=未连接, 1=已连接
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct FillLightConnectionStatus
|
||
{
|
||
public bool IsConnected; // 连接状态
|
||
|
||
public static FillLightConnectionStatus FromBytes(byte[] data)
|
||
{
|
||
var status = new FillLightConnectionStatus();
|
||
if (data != null && data.Length >= 1)
|
||
{
|
||
status.IsConnected = data[0] == 0x01;
|
||
}
|
||
return status;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 可见光激光器控制
|
||
/// 命令 0x28：开关(1)
|
||
/// 开关：0x00=关闭，0x01=开启
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct VisibleLaserControl
|
||
{
|
||
public bool Enable; // 开关
|
||
|
||
public static VisibleLaserControl FromBytes(byte[] data)
|
||
{
|
||
var control = new VisibleLaserControl();
|
||
if (data != null && data.Length >= 1)
|
||
{
|
||
control.Enable = data[0] == 0x01;
|
||
}
|
||
return control;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { Enable ? (byte)0x01 : (byte)0x00 };
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 害虫消灭控制类结构体 (0x40-0x4F)
|
||
|
||
/// <summary>
|
||
/// 角度控制
|
||
/// 命令 0x40：角度范围(2字节)
|
||
/// 数据格式：2字节，小端序，单位：0.1度，范围：1-900（对应0.1度-90度）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct AngleControl
|
||
{
|
||
public ushort AngleRange; // 角度范围（单位：0.1度，范围1-900）
|
||
|
||
/// <summary>
|
||
/// 实际角度值（度）
|
||
/// </summary>
|
||
public float ActualAngle => AngleRange * 0.1f;
|
||
|
||
/// <summary>
|
||
/// 从字节数组解析（小端序）
|
||
/// </summary>
|
||
public static AngleControl FromBytes(byte[] data)
|
||
{
|
||
var control = new AngleControl();
|
||
if (data != null && data.Length >= 2)
|
||
{
|
||
// 小端序：低字节在前，高字节在后
|
||
control.AngleRange = (ushort)(data[0] | (data[1] << 8));
|
||
}
|
||
return control;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组（小端序）
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(AngleRange & 0xFF), // 低字节
|
||
(byte)((AngleRange >> 8) & 0xFF) // 高字节
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置实际角度值
|
||
/// </summary>
|
||
/// <param name="angle">角度值（度），范围0.1-90.0</param>
|
||
public void SetAngle(float angle)
|
||
{
|
||
AngleRange = (ushort)Mathf.Round(angle * 10);
|
||
// 限制范围
|
||
if (AngleRange < 1) AngleRange = 1;
|
||
if (AngleRange > 900) AngleRange = 900;
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"{ActualAngle:F1}度 ({AngleRange})";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 距离控制
|
||
/// 命令 0x41：检测距离(2字节) + 瞄准距离(2字节)
|
||
/// 数据格式：4字节，小端序
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct DistanceControl
|
||
{
|
||
public ushort DetectionDistance; // 检测距离（单位：米）
|
||
public ushort AimDistance; // 瞄准距离（单位：米）
|
||
|
||
/// <summary>
|
||
/// 从字节数组解析（小端序）
|
||
/// </summary>
|
||
public static DistanceControl FromBytes(byte[] data)
|
||
{
|
||
var control = new DistanceControl();
|
||
if (data != null && data.Length >= 4)
|
||
{
|
||
// 小端序解析
|
||
control.DetectionDistance = (ushort)(data[0] | (data[1] << 8));
|
||
control.AimDistance = (ushort)(data[2] | (data[3] << 8));
|
||
}
|
||
return control;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 序列化为字节数组（小端序）
|
||
/// </summary>
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(DetectionDistance & 0xFF),
|
||
(byte)((DetectionDistance >> 8) & 0xFF),
|
||
(byte)(AimDistance & 0xFF),
|
||
(byte)((AimDistance >> 8) & 0xFF)
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"检测距离={DetectionDistance}米, 瞄准距离={AimDistance}米";
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 安全设置类结构体 (0x50-0x5F)
|
||
|
||
/// <summary>
|
||
/// 灵敏度等级枚举
|
||
/// </summary>
|
||
public enum SensitivityLevel : byte
|
||
{
|
||
Low = 0x00, // 低灵敏度
|
||
Medium = 0x01, // 中灵敏度
|
||
High = 0x02 // 高灵敏度
|
||
}
|
||
|
||
/// <summary>
|
||
/// 毫米波雷达设置
|
||
/// 命令 0x50：开关(1) + 灵敏度(1) + 安全距离(2)
|
||
/// 数据格式：4字节，小端序
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct MillimeterWaveSetting
|
||
{
|
||
public bool Enable; // 开关
|
||
public SensitivityLevel Sensitivity; // 灵敏度
|
||
public ushort SafeDistance; // 安全距离（单位：厘米）
|
||
|
||
public static MillimeterWaveSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new MillimeterWaveSetting();
|
||
if (data != null && data.Length >= 4)
|
||
{
|
||
setting.Enable = data[0] == 0x01;
|
||
setting.Sensitivity = (SensitivityLevel)data[1];
|
||
setting.SafeDistance = (ushort)(data[2] | (data[3] << 8));
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(Enable ? 0x01 : 0x00),
|
||
(byte)Sensitivity,
|
||
(byte)(SafeDistance & 0xFF),
|
||
(byte)((SafeDistance >> 8) & 0xFF)
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
string sensStr = Sensitivity switch
|
||
{
|
||
SensitivityLevel.Low => "低",
|
||
SensitivityLevel.Medium => "中",
|
||
SensitivityLevel.High => "高",
|
||
_ => "未知"
|
||
};
|
||
return $"开关={(Enable ? "开启" : "关闭")}, 灵敏度={sensStr}, 安全距离={SafeDistance}cm";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 视觉检测设置
|
||
/// 命令 0x51：开关(1) + 灵敏度(1)
|
||
/// 数据格式：2字节
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct VisualDetectionSetting
|
||
{
|
||
public bool Enable; // 开关
|
||
public SensitivityLevel Sensitivity; // 灵敏度
|
||
|
||
public static VisualDetectionSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new VisualDetectionSetting();
|
||
if (data != null && data.Length >= 2)
|
||
{
|
||
setting.Enable = data[0] == 0x01;
|
||
setting.Sensitivity = (SensitivityLevel)data[1];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(Enable ? 0x01 : 0x00),
|
||
(byte)Sensitivity
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
string sensStr = Sensitivity switch
|
||
{
|
||
SensitivityLevel.Low => "低",
|
||
SensitivityLevel.Medium => "中",
|
||
SensitivityLevel.High => "高",
|
||
_ => "未知"
|
||
};
|
||
return $"开关={(Enable ? "开启" : "关闭")}, 灵敏度={sensStr}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 加速度传感器设置
|
||
/// 命令 0x52：开关(1) + 灵敏度(1) + 振动阈值(1)
|
||
/// 数据格式：3字节
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct AccelerometerSetting
|
||
{
|
||
public bool Enable; // 开关
|
||
public SensitivityLevel Sensitivity; // 灵敏度
|
||
public byte VibrationThreshold; // 振动阈值 (1-255)
|
||
|
||
public static AccelerometerSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new AccelerometerSetting();
|
||
if (data != null && data.Length >= 3)
|
||
{
|
||
setting.Enable = data[0] == 0x01;
|
||
setting.Sensitivity = (SensitivityLevel)data[1];
|
||
setting.VibrationThreshold = data[2];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(Enable ? 0x01 : 0x00),
|
||
(byte)Sensitivity,
|
||
VibrationThreshold
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
string sensStr = Sensitivity switch
|
||
{
|
||
SensitivityLevel.Low => "低",
|
||
SensitivityLevel.Medium => "中",
|
||
SensitivityLevel.High => "高",
|
||
_ => "未知"
|
||
};
|
||
return $"开关={(Enable ? "开启" : "关闭")}, 灵敏度={sensStr}, 振动阈值={VibrationThreshold}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 加速度传感器数据
|
||
/// 命令 0x53：X轴(2) + Y轴(2) + Z轴(2)
|
||
/// 数据格式：6字节，小端序，有符号整数，单位：mg
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct AccelerometerData
|
||
{
|
||
public short X; // X轴加速度 (mg)
|
||
public short Y; // Y轴加速度 (mg)
|
||
public short Z; // Z轴加速度 (mg)
|
||
|
||
public static AccelerometerData FromBytes(byte[] data)
|
||
{
|
||
var accel = new AccelerometerData();
|
||
if (data != null && data.Length >= 6)
|
||
{
|
||
accel.X = (short)(data[0] | (data[1] << 8));
|
||
accel.Y = (short)(data[2] | (data[3] << 8));
|
||
accel.Z = (short)(data[4] | (data[5] << 8));
|
||
}
|
||
return accel;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(X & 0xFF), (byte)((X >> 8) & 0xFF),
|
||
(byte)(Y & 0xFF), (byte)((Y >> 8) & 0xFF),
|
||
(byte)(Z & 0xFF), (byte)((Z >> 8) & 0xFF)
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"X={X}mg, Y={Y}mg, Z={Z}mg";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 温度监控设置
|
||
/// 命令 0x55：告警阈值(1) + 停止阈值(1) + 开关(1)
|
||
/// 数据格式：3字节
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct TemperatureMonitorSetting
|
||
{
|
||
public byte AlarmThreshold; // 告警阈值 (摄氏度)
|
||
public byte StopThreshold; // 停止阈值 (摄氏度)
|
||
public bool Enable; // 开关
|
||
|
||
public static TemperatureMonitorSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new TemperatureMonitorSetting();
|
||
if (data != null && data.Length >= 3)
|
||
{
|
||
setting.AlarmThreshold = data[0];
|
||
setting.StopThreshold = data[1];
|
||
setting.Enable = data[2] == 0x01;
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
AlarmThreshold,
|
||
StopThreshold,
|
||
(byte)(Enable ? 0x01 : 0x00)
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"开关={(Enable ? "开启" : "关闭")}, 告警阈值={AlarmThreshold}°C, 停止阈值={StopThreshold}°C";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 环境变化检测和试射测试
|
||
/// 命令 0x56：读操作返回1字节环境变化状态，写操作触发激光试射测试
|
||
/// 数据格式：1字节
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct EnvironmentChangeTest
|
||
{
|
||
public bool EnvironmentChanged; // 环境变化状态（读操作返回）
|
||
public bool TriggerTest; // 触发测试（写操作发送0x01）
|
||
|
||
public static EnvironmentChangeTest FromBytes(byte[] data)
|
||
{
|
||
var test = new EnvironmentChangeTest();
|
||
if (data != null && data.Length >= 1)
|
||
{
|
||
test.EnvironmentChanged = data[0] == 0x01;
|
||
}
|
||
return test;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { (byte)(TriggerTest ? 0x01 : 0x00) };
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"环境变化={(EnvironmentChanged ? "发生变化" : "没有变化")}";
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 状态查询类结构体 (0xA0-0xBF)
|
||
|
||
/// <summary>
|
||
/// 工作模式枚举
|
||
/// </summary>
|
||
public enum WorkMode : byte
|
||
{
|
||
Standby = 0x00, // 待机模式
|
||
Scan = 0x01, // 扫描模式
|
||
Eliminate = 0x02 // 消杀模式
|
||
}
|
||
|
||
/// <summary>
|
||
/// 工作模式设置
|
||
/// 命令 0xA0：1字节工作模式
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct WorkModeSetting
|
||
{
|
||
public WorkMode Mode;
|
||
|
||
public static WorkModeSetting FromBytes(byte[] data)
|
||
{
|
||
var setting = new WorkModeSetting();
|
||
if (data != null && data.Length >= 1)
|
||
{
|
||
setting.Mode = (WorkMode)data[0];
|
||
}
|
||
return setting;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[] { (byte)Mode };
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
string modeStr = Mode switch
|
||
{
|
||
WorkMode.Standby => "待机",
|
||
WorkMode.Scan => "扫描",
|
||
WorkMode.Eliminate => "消杀",
|
||
_ => "未知"
|
||
};
|
||
return $"工作模式={modeStr}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 硬件状态
|
||
/// 命令 0xA1：返回7字节硬件错误状态
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct HardwareStatus
|
||
{
|
||
public byte TemperatureError; // 温度错误 (0=无, 1=过高, 2=过低)
|
||
public byte MotorError; // 电机错误 (0=无, 1=温度, 2=反馈)
|
||
public byte LaserError; // 激光器错误 (0=无, 1=温度, 2=电压低, 3=电压高)
|
||
public byte VisionError; // 视觉错误 (0=无, 1=通信)
|
||
public byte AccelerometerError; // 加速度错误 (0=无, 1=通信)
|
||
public byte MillimeterWaveError; // 毫米波雷达错误 (0=无, 1=通信)
|
||
public byte LidarError; // 激光雷达错误 (0=无, 1=通信)
|
||
|
||
public static HardwareStatus FromBytes(byte[] data)
|
||
{
|
||
var status = new HardwareStatus();
|
||
if (data != null && data.Length >= 7)
|
||
{
|
||
status.TemperatureError = data[0];
|
||
status.MotorError = data[1];
|
||
status.LaserError = data[2];
|
||
status.VisionError = data[3];
|
||
status.AccelerometerError = data[4];
|
||
status.MillimeterWaveError = data[5];
|
||
status.LidarError = data[6];
|
||
}
|
||
return status;
|
||
}
|
||
|
||
public bool HasError => TemperatureError != 0 || MotorError != 0 || LaserError != 0 ||
|
||
VisionError != 0 || AccelerometerError != 0 || MillimeterWaveError != 0 || LidarError != 0;
|
||
|
||
public override string ToString()
|
||
{
|
||
if (!HasError) return "所有硬件正常";
|
||
var errors = new System.Collections.Generic.List<string>();
|
||
if (TemperatureError != 0) errors.Add($"温度错误({TemperatureError})");
|
||
if (MotorError != 0) errors.Add($"电机错误({MotorError})");
|
||
if (LaserError != 0) errors.Add($"激光器错误({LaserError})");
|
||
if (VisionError != 0) errors.Add($"视觉错误({VisionError})");
|
||
if (AccelerometerError != 0) errors.Add($"加速度错误({AccelerometerError})");
|
||
if (MillimeterWaveError != 0) errors.Add($"毫米波错误({MillimeterWaveError})");
|
||
if (LidarError != 0) errors.Add($"激光雷达错误({LidarError})");
|
||
return string.Join(", ", errors);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设备信息
|
||
/// 命令 0xA2：返回76字节设备信息
|
||
/// 数据格式（76字节，小端序）：
|
||
/// 字节0-15：设备序列号（16字节，ASCII编码）
|
||
/// 字节16-31：设备型号（16字节，ASCII编码）
|
||
/// 字节32-47：设备ID（16字节，ASCII编码）
|
||
/// 字节48-53：BLE MAC地址（6字节）
|
||
/// 字节54-59：WiFi MAC地址（6字节）
|
||
/// 字节60-63：固件版本（uint32_t，4字节小端序）
|
||
/// 字节64-67：硬件版本（uint32_t，4字节小端序）
|
||
/// 字节68-71：OTA版本（uint32_t，4字节小端序）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct DeviceInfo
|
||
{
|
||
public byte[] SerialNumber; // 设备序列号 (16字节)
|
||
public byte[] DeviceModel; // 设备型号 (16字节)
|
||
public byte[] DeviceId; // 设备ID (16字节)
|
||
public byte[] BleMacAddress; // BLE MAC地址 (6字节)
|
||
public byte[] WifiMacAddress; // WiFi MAC地址 (6字节)
|
||
public uint FirmwareVersion; // 固件版本 (4字节)
|
||
public uint HardwareVersion; // 硬件版本 (4字节)
|
||
public uint OtaVersion; // OTA版本 (4字节)
|
||
|
||
public static DeviceInfo FromBytes(byte[] data)
|
||
{
|
||
var info = new DeviceInfo();
|
||
// 始终初始化数组，避免null引用
|
||
info.SerialNumber = new byte[16];
|
||
info.DeviceModel = new byte[16];
|
||
info.DeviceId = new byte[16];
|
||
info.BleMacAddress = new byte[6];
|
||
info.WifiMacAddress = new byte[6];
|
||
|
||
if (data != null)
|
||
{
|
||
// 字节0-15：设备序列号
|
||
if (data.Length >= 16)
|
||
System.Buffer.BlockCopy(data, 0, info.SerialNumber, 0, 16);
|
||
// 字节16-31：设备型号
|
||
if (data.Length >= 32)
|
||
System.Buffer.BlockCopy(data, 16, info.DeviceModel, 0, 16);
|
||
// 字节32-47：设备ID
|
||
if (data.Length >= 48)
|
||
System.Buffer.BlockCopy(data, 32, info.DeviceId, 0, 16);
|
||
// 字节48-53：BLE MAC地址
|
||
if (data.Length >= 54)
|
||
System.Buffer.BlockCopy(data, 48, info.BleMacAddress, 0, 6);
|
||
// 字节54-59：WiFi MAC地址
|
||
if (data.Length >= 60)
|
||
System.Buffer.BlockCopy(data, 54, info.WifiMacAddress, 0, 6);
|
||
// 字节60-63：固件版本（4字节小端序，每位代表一个数字，如 1.0.2.3）
|
||
if (data.Length >= 64)
|
||
info.FirmwareVersion = BitConverter.ToUInt32(data, 60);
|
||
// 字节64-67：硬件版本（4字节小端序，每位代表一个数字，如 0.2.0.0）
|
||
if (data.Length >= 68)
|
||
info.HardwareVersion = BitConverter.ToUInt32(data, 64);
|
||
// 字节68-71：OTA版本（4字节小端序，每位代表一个数字）
|
||
if (data.Length >= 72)
|
||
info.OtaVersion = BitConverter.ToUInt32(data, 68);
|
||
}
|
||
return info;
|
||
}
|
||
|
||
public string GetSerialNumberString() => SerialNumber != null ? System.Text.Encoding.ASCII.GetString(SerialNumber).TrimEnd('\0') : "N/A";
|
||
public string GetDeviceModelString() => DeviceModel != null ? System.Text.Encoding.ASCII.GetString(DeviceModel).TrimEnd('\0') : "N/A";
|
||
public string GetDeviceIdString() => DeviceId != null ? System.Text.Encoding.ASCII.GetString(DeviceId).TrimEnd('\0') : "N/A";
|
||
public string GetBleMacAddressString() => BleMacAddress != null ? BitConverter.ToString(BleMacAddress).Replace("-", ":") : "N/A";
|
||
public string GetWifiMacAddressString() => WifiMacAddress != null ? BitConverter.ToString(WifiMacAddress).Replace("-", ":") : "N/A";
|
||
|
||
/// <summary>
|
||
/// 将版本号转换为 x.x.x.x 格式字符串
|
||
/// </summary>
|
||
private string GetVersionString(uint version)
|
||
{
|
||
byte v1 = (byte)((version >> 24) & 0xFF);
|
||
byte v2 = (byte)((version >> 16) & 0xFF);
|
||
byte v3 = (byte)((version >> 8) & 0xFF);
|
||
byte v4 = (byte)(version & 0xFF);
|
||
return $"{v1}.{v2}.{v3}.{v4}";
|
||
}
|
||
|
||
public string GetFirmwareVersionString() => GetVersionString(FirmwareVersion);
|
||
public string GetHardwareVersionString() => GetVersionString(HardwareVersion);
|
||
public string GetOtaVersionString() => GetVersionString(OtaVersion);
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"序列号={GetSerialNumberString()}, 型号={GetDeviceModelString()}, ID={GetDeviceIdString()}, BLE_MAC={GetBleMacAddressString()}, WiFi_MAC={GetWifiMacAddressString()}, 固件={GetFirmwareVersionString()}, 硬件={GetHardwareVersionString()}, OTA={GetOtaVersionString()}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设备信息写操作
|
||
/// 命令 0xA2 写操作：接收56字节设备信息
|
||
/// 数据格式（56字节，小端序）：
|
||
/// 字节0-15：设备序列号（16字节，ASCII编码）
|
||
/// 字节16-31：设备型号（16字节，ASCII编码）
|
||
/// 字节32-47：设备ID（16字节，ASCII编码）
|
||
/// 字节48-51：固件版本（uint32_t，4字节小端序）
|
||
/// 字节52-55：硬件版本（uint32_t，4字节小端序）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct DeviceInfoWrite
|
||
{
|
||
public byte[] SerialNumber; // 设备序列号 (16字节)
|
||
public byte[] DeviceModel; // 设备型号 (16字节)
|
||
public byte[] DeviceId; // 设备ID (16字节)
|
||
public uint FirmwareVersion; // 固件版本 (4字节)
|
||
public uint HardwareVersion; // 硬件版本 (4字节)
|
||
|
||
public DeviceInfoWrite(string serialNumber = "", string deviceModel = "", string deviceId = "", uint firmwareVersion = 0, uint hardwareVersion = 0)
|
||
{
|
||
SerialNumber = new byte[16];
|
||
DeviceModel = new byte[16];
|
||
DeviceId = new byte[16];
|
||
|
||
// 填充字符串数据
|
||
if (!string.IsNullOrEmpty(serialNumber))
|
||
{
|
||
byte[] serialBytes = System.Text.Encoding.ASCII.GetBytes(serialNumber);
|
||
System.Buffer.BlockCopy(serialBytes, 0, SerialNumber, 0, Mathf.Min(serialBytes.Length, 16));
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(deviceModel))
|
||
{
|
||
byte[] modelBytes = System.Text.Encoding.ASCII.GetBytes(deviceModel);
|
||
System.Buffer.BlockCopy(modelBytes, 0, DeviceModel, 0, Mathf.Min(modelBytes.Length, 16));
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(deviceId))
|
||
{
|
||
byte[] idBytes = System.Text.Encoding.ASCII.GetBytes(deviceId);
|
||
System.Buffer.BlockCopy(idBytes, 0, DeviceId, 0, Mathf.Min(idBytes.Length, 16));
|
||
}
|
||
|
||
FirmwareVersion = firmwareVersion;
|
||
HardwareVersion = hardwareVersion;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
byte[] data = new byte[56];
|
||
|
||
// 字节0-15：设备序列号
|
||
System.Buffer.BlockCopy(SerialNumber, 0, data, 0, 16);
|
||
|
||
// 字节16-31：设备型号
|
||
System.Buffer.BlockCopy(DeviceModel, 0, data, 16, 16);
|
||
|
||
// 字节32-47：设备ID
|
||
System.Buffer.BlockCopy(DeviceId, 0, data, 32, 16);
|
||
|
||
// 字节48-51：固件版本（小端序）
|
||
data[48] = (byte)(FirmwareVersion & 0xFF);
|
||
data[49] = (byte)((FirmwareVersion >> 8) & 0xFF);
|
||
data[50] = (byte)((FirmwareVersion >> 16) & 0xFF);
|
||
data[51] = (byte)((FirmwareVersion >> 24) & 0xFF);
|
||
|
||
// 字节52-55：硬件版本（小端序）
|
||
data[52] = (byte)(HardwareVersion & 0xFF);
|
||
data[53] = (byte)((HardwareVersion >> 8) & 0xFF);
|
||
data[54] = (byte)((HardwareVersion >> 16) & 0xFF);
|
||
data[55] = (byte)((HardwareVersion >> 24) & 0xFF);
|
||
|
||
return data;
|
||
}
|
||
|
||
public string GetSerialNumberString() => System.Text.Encoding.ASCII.GetString(SerialNumber).TrimEnd('\0');
|
||
public string GetDeviceModelString() => System.Text.Encoding.ASCII.GetString(DeviceModel).TrimEnd('\0');
|
||
public string GetDeviceIdString() => System.Text.Encoding.ASCII.GetString(DeviceId).TrimEnd('\0');
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"序列号={GetSerialNumberString()}, 型号={GetDeviceModelString()}, ID={GetDeviceIdString()}, 固件版本={FirmwareVersion}, 硬件版本={HardwareVersion}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 统计数据
|
||
/// 命令 0xA3：返回32字节统计数据
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct StatisticsData
|
||
{
|
||
public uint EliminateCount; // 灭虫数量
|
||
public uint TotalWorkTime; // 总工作时间(秒)
|
||
public uint TodayWorkTime; // 今日工作时间(秒)
|
||
public uint ScanCount; // 扫描次数
|
||
public uint LaserFireCount; // 激光发射次数
|
||
public uint MosquitoDataCount; // 蚊虫数据数量
|
||
public uint DatalogCount; // datalog日志数量
|
||
|
||
public static StatisticsData FromBytes(byte[] data)
|
||
{
|
||
var stats = new StatisticsData();
|
||
if (data != null && data.Length >= 28)
|
||
{
|
||
stats.EliminateCount = (uint)(data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24));
|
||
stats.TotalWorkTime = (uint)(data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24));
|
||
stats.TodayWorkTime = (uint)(data[8] | (data[9] << 8) | (data[10] << 16) | (data[11] << 24));
|
||
stats.ScanCount = (uint)(data[12] | (data[13] << 8) | (data[14] << 16) | (data[15] << 24));
|
||
stats.LaserFireCount = (uint)(data[16] | (data[17] << 8) | (data[18] << 16) | (data[19] << 24));
|
||
stats.MosquitoDataCount = (uint)(data[20] | (data[21] << 8) | (data[22] << 16) | (data[23] << 24));
|
||
stats.DatalogCount = (uint)(data[24] | (data[25] << 8) | (data[26] << 16) | (data[27] << 24));
|
||
}
|
||
return stats;
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"灭虫={EliminateCount}, 总工时={TotalWorkTime/3600}h, 今日={TodayWorkTime/60}min, 扫描={ScanCount}, 激光={LaserFireCount}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 蚊虫数据查询
|
||
/// 命令 0xA4：写操作接收8字节(start_index + end_index)
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct MosquitoDataQuery
|
||
{
|
||
public uint StartIndex; // 起始索引
|
||
public uint EndIndex; // 结束索引
|
||
|
||
public static MosquitoDataQuery FromBytes(byte[] data)
|
||
{
|
||
var query = new MosquitoDataQuery();
|
||
if (data != null && data.Length >= 8)
|
||
{
|
||
query.StartIndex = (uint)(data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24));
|
||
query.EndIndex = (uint)(data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24));
|
||
}
|
||
return query;
|
||
}
|
||
|
||
public byte[] ToBytes()
|
||
{
|
||
return new byte[]
|
||
{
|
||
(byte)(StartIndex & 0xFF), (byte)((StartIndex >> 8) & 0xFF),
|
||
(byte)((StartIndex >> 16) & 0xFF), (byte)((StartIndex >> 24) & 0xFF),
|
||
(byte)(EndIndex & 0xFF), (byte)((EndIndex >> 8) & 0xFF),
|
||
(byte)((EndIndex >> 16) & 0xFF), (byte)((EndIndex >> 24) & 0xFF)
|
||
};
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"索引范围[{StartIndex}-{EndIndex}]";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 传感器数据
|
||
/// 命令 0xA5：返回10字节传感器数据
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct SensorData
|
||
{
|
||
public ushort Temperature; // 温度 (单位: 0.1°C)
|
||
public short AccelX; // X轴加速度 (mg)
|
||
public short AccelY; // Y轴加速度 (mg)
|
||
public short AccelZ; // Z轴加速度 (mg)
|
||
public ushort CapacitorVoltage; // 电容电压 (单位: 0.01V)
|
||
|
||
public static SensorData FromBytes(byte[] data)
|
||
{
|
||
var sensor = new SensorData();
|
||
if (data != null && data.Length >= 10)
|
||
{
|
||
sensor.Temperature = (ushort)(data[0] | (data[1] << 8));
|
||
sensor.AccelX = (short)(data[2] | (data[3] << 8));
|
||
sensor.AccelY = (short)(data[4] | (data[5] << 8));
|
||
sensor.AccelZ = (short)(data[6] | (data[7] << 8));
|
||
sensor.CapacitorVoltage = (ushort)(data[8] | (data[9] << 8));
|
||
}
|
||
return sensor;
|
||
}
|
||
|
||
public float GetTemperatureCelsius() => Temperature * 0.1f;
|
||
public float GetCapacitorVoltage() => CapacitorVoltage * 0.01f;
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"温度={GetTemperatureCelsius():F1}°C, 加速度=({AccelX},{AccelY},{AccelZ})mg, 电容={GetCapacitorVoltage():F2}V";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 蚊虫数据
|
||
/// 通知类型 0x0B：22字节 = 索引(4字节) + 蚊虫数据(18字节)
|
||
/// 蚊虫数据结构：角度(4字节，*1000度) + 距离(2字节，毫米) + 大小(2字节，毫米) + 时间(6字节) + 保留(4字节)
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct MosquitoData
|
||
{
|
||
public uint Index; // 数据索引
|
||
public int Angle; // 角度 (*1000度，支持负数，如90000表示90.000度)
|
||
public ushort Distance; // 距离 (毫米)
|
||
public ushort Size; // 大小 (毫米)
|
||
public byte Year; // 年 (减去2000后的值)
|
||
public byte Month; // 月
|
||
public byte Day; // 日
|
||
public byte Hour; // 时
|
||
public byte Minute; // 分
|
||
public byte Second; // 秒
|
||
public byte[] Reserved; // 保留字节 (4字节)
|
||
|
||
public static MosquitoData FromBytes(byte[] data)
|
||
{
|
||
var mosquito = new MosquitoData();
|
||
if (data != null && data.Length >= 22)
|
||
{
|
||
// 索引 (4字节小端序)
|
||
mosquito.Index = (uint)(data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24));
|
||
|
||
// 角度 (4字节有符号整数，小端序)
|
||
mosquito.Angle = data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24);
|
||
|
||
// 距离 (2字节小端序)
|
||
mosquito.Distance = (ushort)(data[8] | (data[9] << 8));
|
||
|
||
// 大小 (2字节小端序)
|
||
mosquito.Size = (ushort)(data[10] | (data[11] << 8));
|
||
|
||
// 时间 (6字节)
|
||
mosquito.Year = data[12];
|
||
mosquito.Month = data[13];
|
||
mosquito.Day = data[14];
|
||
mosquito.Hour = data[15];
|
||
mosquito.Minute = data[16];
|
||
mosquito.Second = data[17];
|
||
|
||
// 保留字节 (4字节)
|
||
mosquito.Reserved = new byte[4];
|
||
System.Buffer.BlockCopy(data, 18, mosquito.Reserved, 0, 4);
|
||
}
|
||
return mosquito;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取实际角度值（度）
|
||
/// </summary>
|
||
public float GetActualAngle() => Angle / 1000.0f;
|
||
|
||
/// <summary>
|
||
/// 获取完整年份
|
||
/// </summary>
|
||
public int GetFullYear() => 2000 + Year;
|
||
|
||
/// <summary>
|
||
/// 获取时间字符串
|
||
/// </summary>
|
||
public string GetTimeString() => $"{GetFullYear():D4}-{Month:D2}-{Day:D2} {Hour:D2}:{Minute:D2}:{Second:D2}";
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"[{Index}] 角度={GetActualAngle():F3}°, 距离={Distance}mm, 大小={Size}mm, 时间={GetTimeString()}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 蚊虫数据数量查询结果
|
||
/// 命令 0xA4 读操作返回：4字节（设备本地数据条数，小端序）
|
||
/// </summary>
|
||
[Serializable]
|
||
public struct MosquitoDataCount
|
||
{
|
||
public uint Count; // 数据条数
|
||
|
||
public static MosquitoDataCount FromBytes(byte[] data)
|
||
{
|
||
var count = new MosquitoDataCount();
|
||
if (data != null && data.Length >= 4)
|
||
{
|
||
count.Count = (uint)(data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24));
|
||
}
|
||
return count;
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"蚊虫数据条数: {Count}";
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|