// using System;
// using System.Collections.Generic;
// using UnityEngine;
// using System.Threading;
// using GeneralTools;

// namespace DCX.Communication
// {
//     /// <summary>
//     /// DCS项目串口通信管理器
//     /// 基于DCS项目串口通信协议说明书实现
//     /// 支持安卓平台的串口通信
//     /// </summary>
//     public class DCSSerialManager : MonoBehaviour
//     {
//         #region 协议常量
//         // 帧结构常量
//         private const byte FRAME_HEADER_1 = 0xAA;
//         private const byte FRAME_HEADER_2 = 0x55;
//         private const byte FRAME_TAIL_1 = 0x0D;
//         private const byte FRAME_TAIL_2 = 0x0A;

//         // 命令字定义（基于协议文档）
//         public enum CommandType : byte
//         {
//             HandshakeResponse = 0x01,    // 握手应答 + 时间同步（下→上）
//             HandshakeRequest = 0x02,     // 握手请求（上→下）
//             HeartbeatReport = 0x03,      // 心跳上报（上→下）
//             HeartbeatAck = 0x04,         // 心跳应答（下→上）
//             AlarmControl = 0x05,         // 报警控制命令（下→上）
//             DataReport = 0x06,           // 数据上报（上→下）
//             ParameterQuery = 0x07,       // 参数查询或设置（下→上）
//             AlarmFeedback = 0x08,        // 告警状态反馈（上→下）
//             TimeSync = 0x09              // 时间同步命令（下→上）
//         }

//         // 报警代码定义
//         public enum AlarmCode : byte
//         {
//             BatteryLow40 = 0x11,         // 电池电量低（<40%）
//             LaserTempAbnormal = 0x22,    // 激光器温度异常
//             BatteryLow20 = 0x21,         // 电池电量低（<20%）
//             BatteryEmpty5 = 0x31,        // 电池电量空（<5%）
//             BFIAbnormal = 0x32,          // BFI数值异常
//             LaserWorkAbnormal = 0x33,    // 激光器工作异常
//             CommAbnormal = 0x34,         // 通信异常
//             BatteryFault = 0x35,         // 电池故障
//             ACNotConnected = 0x12        // 交流电未连接
//         }
//         #endregion

//         #region 数据结构
//         [Serializable]
//         public struct HeartbeatData
//         {
//             public float bfiValue;          // BFI血流值
//             public byte batteryLevel;       // 电池电量 0-100%
//             public ushort batteryVoltage;   // 电池电压 mV
//             public ushort temperature;      // 内部温度 0.1°C
//             public byte laserStatus;        // 激光器状态 0=异常,1=工作,2=停止
//             public byte powerType;          // 电源类型 0=AC,1=BAT
//             public uint reserved;           // 保留字段
//         }

//         [Serializable]
//         public struct AlarmCommand
//         {
//             public AlarmCode alarmCode;     // 报警代码
//             public byte priority;           // 报警级别 0=低,1=中,2=高
//             public byte status;             // 报警状态 0=清除,1=触发
//         }
//         #endregion

//         #region 事件定义
//         public event Action OnConnected;
//         public event Action OnDisconnected;
//         public event Action<HeartbeatData> OnHeartbeatReceived;
//         public event Action<AlarmCommand> OnAlarmReceived;
//         public event Action<string> OnError;
//         public event Action<byte[]> OnRawDataReceived;
//         #endregion

//         #region 私有字段
//         private ISerialPortAdapter serialPort;
//         private Thread readThread;
//         private bool isRunning = false;
//         private Queue<byte[]> sendQueue = new Queue<byte[]>();
//         private object lockObject = new object();
        
//         private float lastHeartbeatTime = 0f;
//         private float lastDataReportTime = 0f;
//         private bool isHandshakeCompleted = false;
        
//         // 配置参数（从AndroidConfigHelper加载）
//         private string portName;
//         private int baudRate;
//         private int heartbeatInterval;
//         private int communicationTimeout;
//         private bool autoReconnect;
//         private int maxReconnectAttempts;
//         #endregion

//         #region Unity生命周期
//         void Start()
//         {
//             LoadConfiguration();
//             InitializeSerialPort();
//         }

//         void Update()
//         {
//             ProcessSendQueue();
//             CheckHeartbeat();
//             // CheckDataReport();
//         }

//         void OnDestroy()
//         {
//             Disconnect();
//         }
//         #endregion

//         #region 配置加载
//         private void LoadConfiguration()
//         {
//             // 根据平台设置默认串口名称
//             string defaultPortName;
//             #if UNITY_ANDROID && !UNITY_EDITOR
//                 defaultPortName = "/dev/ttyS4";
//             #elif UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
//                 defaultPortName = "COM1";
//             #elif UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
//                 defaultPortName = "/dev/ttyS4";
//             #elif UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
//                 defaultPortName = "/dev/cu.usbserial-1410";
//             #else
//                 defaultPortName = "COM1";
//             #endif
            
//             portName = AndroidConfigHelper.GetConfig("serialPortName", "SerialPort", defaultPortName);
//             baudRate = AndroidConfigHelper.GetConfig("serialBaudRate", "SerialPort", 115200);
//             heartbeatInterval = AndroidConfigHelper.GetConfig("heartbeatInterval", "SerialPort", 1000);
//             communicationTimeout = AndroidConfigHelper.GetConfig("communicationTimeout", "SerialPort", 5000);
//             autoReconnect = AndroidConfigHelper.GetConfig("autoReconnect", "SerialPort", true);
//             maxReconnectAttempts = AndroidConfigHelper.GetConfig("maxReconnectAttempts", "SerialPort", 5);

//             Debug.Log($"DCS串口配置加载完成: {portName}, {baudRate}bps (平台: {Application.platform})");
//         }
//         #endregion

//         #region 串口初始化和连接
//         private void InitializeSerialPort()
//         {
//             try
//             {
// #if UNITY_ANDROID && !UNITY_EDITOR
//                 // 安卓平台使用JNI调用原生串口
//                 serialPort = new AndroidSerialPortAdapter();
// #elif UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
//                 // Windows平台使用真实串口
//                 serialPort = new WindowsSerialPortAdapter();
//                 Debug.Log("DCS使用Windows真实串口");
// #elif UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
//                 // Linux平台使用真实串口
//                 serialPort = new WindowsSerialPortAdapter(); // 复用Windows适配器
//                 Debug.Log("DCS使用Linux真实串口");
// #else
//                 // 其他平台使用模拟器
//                 serialPort = new SimulatedSerialPortAdapter();
//                 Debug.LogWarning("DCS使用串口模拟器（未支持平台）");
// #endif
//                 Connect();
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"DCS串口初始化失败: {e.Message}");
//                 OnError?.Invoke($"串口初始化失败: {e.Message}");
//             }
//         }

//         public void Connect()
//         {
//             try
//             {
//                 if (serialPort != null && serialPort.Open(portName, baudRate))
//                 {
//                     isRunning = true;
//                     StartReadThread();
//                     SendHandshakeRequest();
//                     OnConnected?.Invoke();
//                     Debug.Log("串口连接成功");
//                 }
//                 else
//                 {
//                     OnError?.Invoke("串口连接失败");
//                 }
//             }
//             catch (Exception e)
//             {
//                 OnError?.Invoke($"连接异常: {e.Message}");
//             }
//         }

//         public void Disconnect()
//         {
//             isRunning = false;
            
//             if (readThread != null && readThread.IsAlive)
//             {
//                 readThread.Join(1000); // 等待读取线程结束
//             }

//             serialPort?.Close();
//             OnDisconnected?.Invoke();
//             Debug.Log("串口已断开");
//         }
//         #endregion

//         #region 数据发送和接收
//         private void StartReadThread()
//         {
//             readThread = new Thread(ReadDataThread)
//             {
//                 IsBackground = true
//             };
//             readThread.Start();
//         }

//         private void ReadDataThread()
//         {
//             byte[] buffer = new byte[1024];
            
//             while (isRunning)
//             {
//                 try
//                 {
//                     if (serialPort != null && serialPort.IsOpen)
//                     {
//                         int bytesRead = serialPort.Read(buffer, 0, buffer.Length);
//                         if (bytesRead > 0)
//                         {
//                             byte[] data = new byte[bytesRead];
//                             Array.Copy(buffer, 0, data, 0, bytesRead);
                            
//                             // 在主线程处理数据
//                             MainThreadDispatcher.Enqueue(() => ProcessReceivedData(data));
//                         }
//                     }
//                 }
//                 catch (Exception e)
//                 {
//                     MainThreadDispatcher.Enqueue(() => OnError?.Invoke($"读取数据异常: {e.Message}"));
//                 }
                
//                 Thread.Sleep(10); // 避免过度占用CPU
//             }
//         }

//         private void ProcessReceivedData(byte[] data)
//         {
//             OnRawDataReceived?.Invoke(data);
            
//             // 解析协议帧
//             for (int i = 0; i < data.Length - 6; i++) // 最小帧长度检查
//             {
//                 if (data[i] == FRAME_HEADER_1 && data[i + 1] == FRAME_HEADER_2)
//                 {
//                     if (TryParseFrame(data, i, out var frame))
//                     {
//                         ProcessFrame(frame);
//                     }
//                 }
//             }
//         }

//         private bool TryParseFrame(byte[] data, int startIndex, out ProtocolFrame frame)
//         {
//             frame = new ProtocolFrame();
            
//             try
//             {
//                 if (startIndex + 6 >= data.Length) return false;
                
//                 frame.Command = (CommandType)data[startIndex + 2];
//                 frame.DataLength = data[startIndex + 3];
                
//                 int totalFrameLength = 4 + frame.DataLength + 3; // 帧头+命令+长度+数据+校验+帧尾
//                 if (startIndex + totalFrameLength > data.Length) return false;
                
//                 frame.Data = new byte[frame.DataLength];
//                 Array.Copy(data, startIndex + 4, frame.Data, 0, frame.DataLength);
                
//                 frame.Checksum = data[startIndex + 4 + frame.DataLength];
                
//                 // 验证校验和
//                 byte calculatedChecksum = CalculateChecksum(data, startIndex + 2, 2 + frame.DataLength);
//                 if (calculatedChecksum != frame.Checksum)
//                 {
//                     Debug.LogWarning("校验和不匹配");
//                     return false;
//                 }
                
//                 // 验证帧尾
//                 if (data[startIndex + 5 + frame.DataLength] != FRAME_TAIL_1 ||
//                     data[startIndex + 6 + frame.DataLength] != FRAME_TAIL_2)
//                 {
//                     Debug.LogWarning("帧尾不匹配");
//                     return false;
//                 }
                
//                 return true;
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"解析帧失败: {e.Message}");
//                 return false;
//             }
//         }

//         private void ProcessFrame(ProtocolFrame frame)
//         {
//             switch (frame.Command)
//             {
//                 case CommandType.HeartbeatReport:
//                     ProcessHeartbeatReport(frame.Data);
//                     SendHeartbeatAck();
//                     break;
                    
//                 case CommandType.DataReport:
//                     ProcessDataReport(frame.Data);
//                     break;
                    
//                 case CommandType.AlarmFeedback:
//                     ProcessAlarmFeedback(frame.Data);
//                     break;
                    
//                 case CommandType.HandshakeRequest:
//                     ProcessHandshakeRequest(frame.Data);
//                     break;
                    
//                 default:
//                     Debug.Log($"收到未处理的命令: {frame.Command}");
//                     break;
//             }
//         }

//         private void ProcessHeartbeatReport(byte[] data)
//         {
//             if (data.Length >= 15) // HeartbeatData结构体大小
//             {
//                 HeartbeatData heartbeat = new HeartbeatData
//                 {
//                     bfiValue = BitConverter.ToSingle(data, 0),
//                     batteryLevel = data[4],
//                     batteryVoltage = BitConverter.ToUInt16(data, 5),
//                     temperature = BitConverter.ToUInt16(data, 7),
//                     laserStatus = data[9],
//                     powerType = data[10],
//                     reserved = BitConverter.ToUInt32(data, 11)
//                 };
                
//                 OnHeartbeatReceived?.Invoke(heartbeat);
//                 lastHeartbeatTime = Time.time;
//             }
//         }

//         private void ProcessDataReport(byte[] data)
//         {
//             // 处理数据上报，格式与心跳报告相同
//             ProcessHeartbeatReport(data);
//             lastDataReportTime = Time.time;
//         }

//         private void ProcessAlarmFeedback(byte[] data)
//         {
//             if (data.Length >= 3)
//             {
//                 AlarmCommand alarm = new AlarmCommand
//                 {
//                     alarmCode = (AlarmCode)data[0],
//                     priority = data[1],
//                     status = data[2]
//                 };
                
//                 OnAlarmReceived?.Invoke(alarm);
//             }
//         }

//         private void ProcessHandshakeRequest(byte[] data)
//         {
//             Debug.Log("收到握手请求，发送时间同步应答");
//             SendHandshakeResponse();
//             isHandshakeCompleted = true;
//         }
//         #endregion

//         #region 协议命令发送
//         public void SendHandshakeRequest()
//         {
//             byte[] data = { 0x01 }; // 固件版本
//             SendFrame(CommandType.HandshakeRequest, data);
//         }

//         public void SendHandshakeResponse()
//         {
//             DateTime now = DateTime.Now;
//             byte[] data = {
//                 (byte)(now.Year % 100),
//                 (byte)now.Month,
//                 (byte)now.Day,
//                 (byte)now.Hour,
//                 (byte)now.Minute,
//                 (byte)now.Second
//             };
//             SendFrame(CommandType.HandshakeResponse, data);
//         }

//         public void SendHeartbeatAck()
//         {
//             byte[] data = { 0x00 }; // 简单应答
//             SendFrame(CommandType.HeartbeatAck, data);
//         }

//         public void SendAlarmControl(AlarmCode alarmCode, byte priority, byte status)
//         {
//             byte[] data = { (byte)alarmCode, priority, status };
//             SendFrame(CommandType.AlarmControl, data);
//         }

//         private void SendFrame(CommandType command, byte[] data)
//         {
//             try
//             {
//                 List<byte> frame = new List<byte>();
                
//                 // 帧头
//                 frame.Add(FRAME_HEADER_1);
//                 frame.Add(FRAME_HEADER_2);
                
//                 // 命令字
//                 frame.Add((byte)command);
                
//                 // 数据长度
//                 frame.Add((byte)data.Length);
                
//                 // 数据
//                 frame.AddRange(data);
                
//                 // 校验和
//                 byte checksum = CalculateChecksum(frame.ToArray(), 2, 2 + data.Length);
//                 frame.Add(checksum);
                
//                 // 帧尾
//                 frame.Add(FRAME_TAIL_1);
//                 frame.Add(FRAME_TAIL_2);
                
//                 var frameArray = frame.ToArray();
//                 var hexString = BitConverter.ToString(frameArray).Replace("-", " ");
//                 Debug.Log($"[DCS发送队列] {GetCommandName(command)}: {hexString}");
                
//                 lock (lockObject)
//                 {
//                     sendQueue.Enqueue(frameArray);
//                 }
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"DCS发送帧失败: {e.Message}");
//                 OnError?.Invoke($"发送帧失败: {e.Message}");
//             }
//         }
        
//         private string GetCommandName(CommandType command)
//         {
//             return command switch
//             {
//                 CommandType.HandshakeResponse => "握手应答",
//                 CommandType.HandshakeRequest => "握手请求",
//                 CommandType.HeartbeatReport => "心跳上报",
//                 CommandType.HeartbeatAck => "心跳应答",
//                 CommandType.AlarmControl => "报警控制",
//                 CommandType.DataReport => "数据上报",
//                 CommandType.ParameterQuery => "参数查询",
//                 CommandType.AlarmFeedback => "报警反馈",
//                 CommandType.TimeSync => "时间同步",
//                 _ => $"未知命令({(byte)command:X2})"
//             };
//         }

//         private void ProcessSendQueue()
//         {
//             lock (lockObject)
//             {
//                 while (sendQueue.Count > 0)
//                 {
//                     byte[] frame = sendQueue.Dequeue();
//                     try
//                     {
//                         if (serialPort != null && serialPort.IsOpen)
//                         {
//                             serialPort.Write(frame, 0, frame.Length);
//                             var hexString = BitConverter.ToString(frame).Replace("-", " ");
//                             Debug.Log($"[DCS串口发送] {hexString}");
//                         }
//                         else
//                         {
//                             Debug.LogError("DCS串口未打开，无法发送数据");
//                         }
//                     }
//                     catch (Exception e)
//                     {
//                         Debug.LogError($"DCS串口写入失败: {e.Message}");
//                         OnError?.Invoke($"串口写入失败: {e.Message}");
//                     }
//                 }
//             }
//         }
//         #endregion

//         #region 辅助方法
//         private byte CalculateChecksum(byte[] data, int offset, int length)
//         {
//             byte checksum = 0;
//             for (int i = offset; i < offset + length; i++)
//             {
//                 checksum ^= data[i];
//             }
//             return checksum;
//         }

//         private void CheckHeartbeat()
//         {
//             if (isHandshakeCompleted && Time.time - lastHeartbeatTime > communicationTimeout / 1000f)
//             {
//                 Debug.LogWarning("心跳超时");
//                 if (autoReconnect)
//                 {
//                     Reconnect();
//                 }
//             }
//         }

//         private void CheckDataReport()
//         {
//             // 检查数据上报间隔
//             float dataReportInterval = AndroidConfigHelper.GetConfig("dataReportInterval", "SerialPort", 1000) / 1000f;
//             if (Time.time - lastDataReportTime > dataReportInterval * 2)
//             {
//                 Debug.LogWarning("数据上报超时");
//             }
//         }

//         private void Reconnect()
//         {
//             Debug.Log("尝试重连...");
//             Disconnect();
//             Invoke(nameof(Connect), 2f); // 2秒后重连
//         }
//         #endregion

//         #region 内部数据结构
//         private struct ProtocolFrame
//         {
//             public CommandType Command;
//             public byte DataLength;
//             public byte[] Data;
//             public byte Checksum;
//         }
//         #endregion
//     }

//     #region 串口适配器接口
//     public interface ISerialPortAdapter
//     {
//         bool Open(string portName, int baudRate);
//         void Close();
//         bool IsOpen { get; }
//         int Read(byte[] buffer, int offset, int count);
//         void Write(byte[] buffer, int offset, int count);
//     }

//     // Windows平台串口适配器（使用System.IO.Ports）
//     public class WindowsSerialPortAdapter : ISerialPortAdapter
//     {
// #if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN || UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
//         private System.IO.Ports.SerialPort serialPort;
        
//         public bool IsOpen => serialPort?.IsOpen ?? false;

//         public bool Open(string portName, int baudRate)
//         {
//             try
//             {
//                 serialPort = new System.IO.Ports.SerialPort(portName, baudRate, System.IO.Ports.Parity.None, 8, System.IO.Ports.StopBits.One)
//                 {
//                     ReadTimeout = 1000,
//                     WriteTimeout = 1000
//                 };
                
//                 serialPort.Open();
//                 Debug.Log($"Windows串口打开成功: {portName} @ {baudRate}");
//                 return true;
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Windows串口打开失败: {e.Message}");
//                 return false;
//             }
//         }

//         public void Close()
//         {
//             try
//             {
//                 if (serialPort?.IsOpen == true)
//                 {
//                     serialPort.Close();
//                     serialPort.Dispose();
//                     serialPort = null;
//                     Debug.Log("Windows串口已关闭");
//                 }
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Windows串口关闭失败: {e.Message}");
//             }
//         }

//         public int Read(byte[] buffer, int offset, int count)
//         {
//             try
//             {
//                 if (serialPort != null && serialPort.IsOpen && serialPort.BytesToRead > 0)
//                 {
//                     return serialPort.Read(buffer, offset, count);
//                 }
//                 return 0;
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Windows串口读取失败: {e.Message}");
//                 return 0;
//             }
//         }

//         public void Write(byte[] buffer, int offset, int count)
//         {
//             try
//             {
//                 if (serialPort != null && serialPort.IsOpen)
//                 {
//                     serialPort.Write(buffer, offset, count);
//                 }
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Windows串口写入失败: {e.Message}");
//             }
//         }
// #else
//         public bool IsOpen => false;
//         public bool Open(string portName, int baudRate) { Debug.LogWarning("WindowsSerialPortAdapter不支持此平台"); return false; }
//         public void Close() { }
//         public int Read(byte[] buffer, int offset, int count) { return 0; }
//         public void Write(byte[] buffer, int offset, int count) { }
// #endif
//     }

//     // 安卓平台串口适配器（需要JNI实现）
//     public class AndroidSerialPortAdapter : ISerialPortAdapter
//     {
//         private AndroidJavaObject serialPortJNI;
        
//         public bool IsOpen { get; private set; }

//         public bool Open(string portName, int baudRate)
//         {
//             try
//             {
// #if UNITY_ANDROID && !UNITY_EDITOR
//                 serialPortJNI = new AndroidJavaObject("com.dcx.serialport.SerialPortHelper");
//                 bool result = serialPortJNI.Call<bool>("openSerialPort", portName, baudRate);
//                 IsOpen = result;
//                 return result;
// #else
//                 return false;
// #endif
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Android串口打开失败: {e.Message}");
//                 return false;
//             }
//         }

//         public void Close()
//         {
//             try
//             {
// #if UNITY_ANDROID && !UNITY_EDITOR
//                 serialPortJNI?.Call("closeSerialPort");
// #endif
//                 IsOpen = false;
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Android串口关闭失败: {e.Message}");
//             }
//         }

//         public int Read(byte[] buffer, int offset, int count)
//         {
//             try
//             {
// #if UNITY_ANDROID && !UNITY_EDITOR
//                 byte[] data = serialPortJNI.Call<byte[]>("readData", count);
//                 if (data != null && data.Length > 0)
//                 {
//                     Array.Copy(data, 0, buffer, offset, Math.Min(data.Length, count));
//                     return data.Length;
//                 }
// #endif
//                 return 0;
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Android串口读取失败: {e.Message}");
//                 return 0;
//             }
//         }

//         public void Write(byte[] buffer, int offset, int count)
//         {
//             try
//             {
// #if UNITY_ANDROID && !UNITY_EDITOR
//                 byte[] data = new byte[count];
//                 Array.Copy(buffer, offset, data, 0, count);
//                 serialPortJNI.Call("writeData", data);
// #endif
//             }
//             catch (Exception e)
//             {
//                 Debug.LogError($"Android串口写入失败: {e.Message}");
//             }
//         }
//     }

//     // 模拟串口适配器（用于测试）
//     public class SimulatedSerialPortAdapter : ISerialPortAdapter
//     {
//         public bool IsOpen { get; private set; }
        
//         private Queue<byte> simulatedData = new Queue<byte>();
//         private System.Random random = new System.Random();

//         public bool Open(string portName, int baudRate)
//         {
//             IsOpen = true;
//             Debug.Log($"模拟串口已打开: {portName}@{baudRate}");
//             return true;
//         }

//         public void Close()
//         {
//             IsOpen = false;
//             Debug.Log("模拟串口已关闭");
//         }

//         public int Read(byte[] buffer, int offset, int count)
//         {
//             // 模拟接收心跳数据
//             if (simulatedData.Count == 0 && random.NextDouble() < 0.1) // 10%概率生成数据
//             {
//                 GenerateSimulatedHeartbeat();
//             }

//             int bytesRead = 0;
//             while (simulatedData.Count > 0 && bytesRead < count)
//             {
//                 buffer[offset + bytesRead] = simulatedData.Dequeue();
//                 bytesRead++;
//             }
            
//             return bytesRead;
//         }

//         public void Write(byte[] buffer, int offset, int count)
//         {
//             string hex = BitConverter.ToString(buffer, offset, count);
//             Debug.Log($"模拟串口发送: {hex}");
//         }

//         private void GenerateSimulatedHeartbeat()
//         {
//             // 生成模拟心跳帧
//             List<byte> frame = new List<byte>
//             {
//                 0xAA, 0x55, // 帧头
//                 0x03, // 心跳报告命令
//                 0x0F, // 数据长度15字节
//             };
            
//             // BFI值 (float)
//             byte[] bfiBytes = BitConverter.GetBytes(50.0f + (float)(random.NextDouble() - 0.5) * 20);
//             frame.AddRange(bfiBytes);
            
//             // 电池电量
//             frame.Add((byte)(80 + random.Next(0, 20)));
            
//             // 电池电压 (mV)
//             byte[] voltageBytes = BitConverter.GetBytes((ushort)(3700 + random.Next(0, 500)));
//             frame.AddRange(voltageBytes);
            
//             // 温度
//             byte[] tempBytes = BitConverter.GetBytes((ushort)(250 + random.Next(0, 100))); // 25.0-35.0°C
//             frame.AddRange(tempBytes);
            
//             // 激光器状态
//             frame.Add(0x01); // 工作中
            
//             // 电源类型
//             frame.Add(0x01); // 电池供电
            
//             // 保留字段
//             frame.AddRange(new byte[4]);
            
//             // 校验和
//             byte checksum = 0;
//             for (int i = 2; i < frame.Count; i++)
//             {
//                 checksum ^= frame[i];
//             }
//             frame.Add(checksum);
            
//             // 帧尾
//             frame.Add(0x0D);
//             frame.Add(0x0A);
            
//             foreach (byte b in frame)
//             {
//                 simulatedData.Enqueue(b);
//             }
//         }
//     }

//     // 主线程调度器（用于在主线程处理串口数据）
//     public class MainThreadDispatcher : MonoBehaviour
//     {
//         private static MainThreadDispatcher instance;
//         private static Queue<Action> executionQueue = new Queue<Action>();

//         public static void Enqueue(Action action)
//         {
//             lock (executionQueue)
//             {
//                 executionQueue.Enqueue(action);
//             }
//         }

//         void Awake()
//         {
//             if (instance == null)
//             {
//                 instance = this;
//                 DontDestroyOnLoad(gameObject);
//             }
//             else
//             {
//                 Destroy(gameObject);
//             }
//         }

//         void Update()
//         {
//             lock (executionQueue)
//             {
//                 while (executionQueue.Count > 0)
//                 {
//                     executionQueue.Dequeue().Invoke();
//                 }
//             }
//         }
//     }
//     #endregion
// }