yuqucheng/killapp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
killapp/Assets/Scripts/BLEProtocol/BLEProtocolStructs.cs

2173 lines
76 KiB
C#
Raw Normal View History

初版 蓝牙工具
2026-03-30 16:25:00 +08:00
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
}
Reference in New Issue Copy Permalink