aivfo-tl-3.0/ivf_tl_operate_2.0/ivf_tl_Entity/ComEntitys/ComBin.cs

using ivf_tl_Entity.GlobalEnums;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ivf_tl_Entity.ComEntitys
{
    /// <summary>
    /// 封装指令发送以及解析线程
    /// </summary>
    public class ComBin
    {
        /// <summary>
        /// 异常日志
        /// 异常、名称、参数
        /// </summary>
        public event Action<Exception, string, string, LogEnum> ExceptionLogEvent;

        /// <summary>
        /// 错误日志
        /// </summary>
        public event Action<string, LogEnum> ErrorLogEvent;

        /// <summary>
        /// 指令记录日志
        /// </summary>
        public event Action<int, DateTime, string, LogEnum> CommandLogEvent;

        /// <summary>
        /// 调试信息输出
        /// </summary>
        public event Action<string> AddMessageInfoEvent;

        public ComBin(int houseId, string portName)
        {
            this.houseId = houseId;
            this.portName = portName;
            _commandQueue = new Queue<CustomProtocol>();
            _channel = new Channel(houseId, portName);
            _channel.DataReceived += _channel_DataReceived;
            _channel.ExceptionLogEvent += _channel_ExceptionLogEvent;
            _channel.ErrorLogEvent += _channel_ErrorLogEvent;
            _channel.CommandLogEvent += _channel_CommandLogEvent; ;
            StartSendCommandThread();
        }

        private void _channel_CommandLogEvent(int arg1, DateTime arg2, string arg3, LogEnum arg4)
        {
            CommandLogEvent?.Invoke(arg1, arg2, arg3, arg4);
        }

        private void _channel_ErrorLogEvent(string arg1, LogEnum arg2)
        {
            ErrorLogEvent?.Invoke(arg1, arg2);
        }

        private void _channel_ExceptionLogEvent(Exception arg1, string arg2, string arg3, LogEnum arg4)
        {
            ExceptionLogEvent?.Invoke(arg1, arg2, arg3, arg4);
        }

        public Channel _channel { get; set; } = null;

        /// <summary>
        /// 是否停止发送指令线程循环
        /// </summary>
        public bool IsStop = false;

        /// <summary>
        /// 指令发送失败以后是否无限重发
        /// </summary>
        public bool IsStopWhile = true;

        private int houseId = 0;

        private string portName = null;

        /// <summary>
        /// 命令队列
        /// </summary>
        private Queue<CustomProtocol> _commandQueue;

        /// <summary>
        /// 指令超时重发等待毫秒
        /// </summary>
        private int milliseconds = 1000 * 30;

        /// <summary>
        /// 发送指令的线程同步控制器
        /// </summary>
        private AutoResetEvent sendAutoResetEvent = new AutoResetEvent(false);

        /// <summary>
        /// 运行线程等待指令的同步控制器
        /// </summary>
        private AutoResetEvent taskAutoResetEvent = new AutoResetEvent(false);

        /// <summary>
        /// 指令发送锁
        /// </summary>
        private object SendCommandLock = new object();

        /// <summary>
        /// 指令计数
        /// </summary>
        private double commandNumber = 1;

        /// <summary>
        /// 开启发送指令线程
        /// </summary>
        public void StartSendCommandThread()
        {
            Task.Factory.StartNew(() =>
            {
                Stopwatch SendStopWatch = new Stopwatch();
                CustomProtocol customProtocol = null;
                while (true)
                {
                    try
                    {
                        if (IsStop)
                        {
                            return;
                        }
                        lock (_commandQueue)
                        {
                            if (_commandQueue.Any())
                            {
                                customProtocol = _commandQueue.Dequeue();
                            }
                        }
                        if (customProtocol != null)
                        {
                            SendStopWatch.Restart();

                            string Content = $"[{houseId}][{portName}][{customProtocol.commandNumber}][{customProtocol.commandType}][Send:{StringHelper.ByteToHexStr(customProtocol.sendBuffer)}]";

                            if (customProtocol.commandType == Enums.VerticalMotorAbsolute)
                            {
                                AddMessageInfoEvent?.Invoke($"[{customProtocol.commandType}][发:{StringHelper.ByteToHexStr(customProtocol.sendBuffer)}][垂直电机位置：{customProtocol.VerticalMotorPulse}]");
                            }
                            else
                            {
                                AddMessageInfoEvent?.Invoke($"[{customProtocol.commandType}][发:{StringHelper.ByteToHexStr(customProtocol.sendBuffer)}]");
                            }
                            

                            customProtocol.IsSuccess = SendCommand(customProtocol, Content);

                            string Content11 = $"{Content}[Rec:{StringHelper.ByteToHexStr(customProtocol.receivedBuffer)}]";

                            if (customProtocol.WaitTime != 0)
                            {
                                CommandLogEvent?.Invoke(houseId, DateTime.Now, $"{Content11}[等待{customProtocol.WaitTime}毫秒]", LogEnum.HouseComRecord);
                                Thread.Sleep(customProtocol.WaitTime);
                            }

                            CommandLogEvent?.Invoke(houseId, DateTime.Now, $"{Content11}[本轮指令总耗时:{StringHelper.TimeToString(SendStopWatch.Elapsed)}][End]", LogEnum.HouseComRecord);

                            SendStopWatch.Stop();
                            if (customProtocol.IsWaitOne)
                            {
                                taskAutoResetEvent.Set();
                            }
                            customProtocol = null;
                        }
                        else
                        {
                            //CommandLogEvent?.Invoke(houseId, DateTime.Now, $"空指令，等待50毫秒", LogEnum.HouseComRecord);
                            Thread.Sleep(500);
                        }
                    }
                    catch (Exception ex)
                    {
                        ExceptionLogEvent?.Invoke(ex, $"[{houseId}][{portName}]指令发送线程", null, LogEnum.RunException);
                    }
                }
            }, TaskCreationOptions.LongRunning);
        }

        /// <summary>
        /// 指令发送
        /// </summary>
        /// <param name="customProtocol"></param>
        /// <param name="Content"></param>
        private bool SendCommand(CustomProtocol customProtocol, string Content)
        {
            try
            {
                bool sendRs = _channel.Send(customProtocol);
                bool result = sendAutoResetEvent.WaitOne(milliseconds);//延时等待下位机回复
                // M8-P3b：单条指令收发为高频，走调试级（落本地文件、默认不入库，见 14§4）。全 try 兜底。
                try
                {
                    Aivfo.OperationLog.OperationLogger.Log("串口",
                        $"指令-{customProtocol.commandType}",
                        input: Content,
                        result: result ? "成功" : "失败",
                        level: Aivfo.OperationLog.OpLogLevel.Debug,
                        houseSn: houseId);
                }
                catch { }
                return result;
            }
            catch (Exception ex)
            {
                ExceptionLogEvent?.Invoke(ex, $"{Content}指令发送", null, LogEnum.RunException);
                return false;
            }
        }

        private void _channel_DataReceived(CustomProtocol obj)
        {
            AddMessageInfoEvent?.Invoke($"[{obj.commandType}][收:{StringHelper.ByteToHexStr(obj.receivedBuffer)}]");
            sendAutoResetEvent.Set();
        }

        /// <summary>
        /// 发送封装
        /// </summary>
        /// <param name="custom"></param>
        private void Enqueue(CustomProtocol custom)
        {
            lock (_commandQueue)
            {
                _commandQueue.Enqueue(custom);
            }
        }

        public bool OpenPort()
        {
            // M8-P3b：串口操作级埋点（打开端口入库）。全 try 兜底。
            bool rs = _channel.OpenPort();
            try
            {
                Aivfo.OperationLog.OperationLogger.Log("串口", "打开端口",
                    input: new { houseId, portName },
                    result: rs ? "成功" : "失败",
                    houseSn: houseId);
            }
            catch { }
            return rs;
        }

        public bool ClosePort()
        {
            // M8-P3b：串口操作级埋点（关闭端口入库）。全 try 兜底。
            bool rs = _channel.ClosePort();
            try
            {
                Aivfo.OperationLog.OperationLogger.Log("串口", "关闭端口",
                    input: new { houseId, portName },
                    result: rs ? "成功" : "失败",
                    houseSn: houseId);
            }
            catch { }
            return rs;
        }

        #region 舱室状态

        public bool AutoWait(CustomProtocol custom, bool auto)
        {
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.commandType = Enums.AutoAirSwap;
            custom.CreateAutoCommand(auto);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return false;
            return custom.receivedBuffer[custom.lenght - 2] == 0;
        }

        /// <summary>
        /// 握手指令
        /// </summary>
        public int ShakeHandsWait(CustomProtocol custom)
        {
            //握手
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.commandType = Enums.ShakeHands;
            custom.CreateHandCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseShakeHandsCommand(custom.receivedBuffer);
        }

        /// <summary>
        ///  读舱门状态
        /// </summary>
        /// <param name="custom"></param>
        /// <returns></returns>
        public State DoorStatusWait(CustomProtocol custom)
        {
            custom.commandType = Enums.DoorStatus;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadDoorCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return State.未知;
            return Analysiser.ParseDoorStatus(custom.receivedBuffer);
        }

        /// <summary>
        /// 舱室温度
        /// </summary>
        /// <param name="custom"></param>
        /// <returns></returns>
        public decimal TemperatureWait(CustomProtocol custom)
        {
            custom.commandType = Enums.Temperature;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadTemperatureCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1m;
            return Analysiser.ParseTemperatureCommand(custom.receivedBuffer);
        }

        /// <summary>
        /// 上盖板温度
        /// </summary>
        /// <param name="custom"></param>
        /// <returns></returns>
        public decimal ShangTemperatureWait(CustomProtocol custom)
        {
            custom.commandType = Enums.Temperature;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadShangTemperatureCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1m;
            return Analysiser.ParseTemperatureCommand(custom.receivedBuffer);
        }

        /// <summary>
        /// 玻璃片下方温度
        /// </summary>
        /// <param name="custom"></param>
        /// <returns></returns>
        public decimal BoLiTemperatureWait(CustomProtocol custom)
        {
            custom.commandType = Enums.BoLiTemperature;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadBoLiTemperatureCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1m;
            return Analysiser.ParseTemperatureCommand(custom.receivedBuffer);
        }

        /// <summary>
        /// 舱室压力
        /// </summary>
        /// <param name="custom"></param>
        /// <returns></returns>
        public decimal PressureWait(CustomProtocol custom)
        {
            custom.commandType = Enums.Pressure;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadPressureCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1m;
            return Analysiser.ParsePressureCommand(custom.receivedBuffer);
        }

        /// <summary>
        /// 获取缓冲瓶状态
        /// </summary>
        /// <returns></returns>
        public (decimal, decimal, decimal) BufferBottleState(CustomProtocol custom)
        {
            custom.commandType = Enums.BufferBottlePressure;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateBufferBottlePressureCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return (-1m, -1m, -1m);
            return (Analysiser.ParsePressureCommand(custom.receivedBuffer), Analysiser.ParseTLTemperature1Command(custom.receivedBuffer), Analysiser.ParseTLTemperature2Command(custom.receivedBuffer));
        }
        #endregion

        #region 电机

        /// <summary>
        /// 水平电机复位
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        public bool HorizontalMotorResetWait(CustomProtocol custom, int waitTime)
        {
            custom.commandType = Enums.HorizontalMotorReset;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateHorizontalMotorResetCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 水平电机绝对运动
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        /// <param name="zero"></param>
        /// <param name="newValue"></param>
        public bool HorizontalMotorAbsoluteWait(CustomProtocol custom, int waitTime, int newValue)
        {
            custom.commandType = Enums.HorizontalMotorAbsolute;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.HorizontalMotorPulse = newValue;
            custom.CreateHorizontalMotorMoveToCommand(newValue);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 水平电机正向运动
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        /// <param name="newValue"></param>
        /// <returns></returns>
        public bool HorizontalMotorForwardWait(CustomProtocol custom, int waitTime, int newValue)
        {
            custom.commandType = Enums.HorizontalMotorForward;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.HorizontalMotorPulse = newValue;
            custom.CreateHorizontalMotorForwardCommand(newValue);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 水平电机反向运动
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        /// <param name="newValue"></param>
        /// <returns></returns>
        public bool HorizontalMotorBackward(CustomProtocol custom, int waitTime, int newValue)
        {
            custom.commandType = Enums.HorizontalMotorBackward;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.HorizontalMotorPulse = newValue;
            custom.CreateHorizontalMotorBackwardCommand(newValue);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }


        /// <summary>
        /// 读水平电机位置
        /// </summary>
        public int ReadHorizontalMotorWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadHorizontalMotor;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadHorizontalMotorCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseCurrentMotor(custom.receivedBuffer);
        }

        /// <summary>
        /// 读垂直电机位置
        /// </summary>
        public int ReadVerticalMotorWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadVerticalMotor;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadVerticalMotorCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseCurrentMotor(custom.receivedBuffer);
        }

        /// <summary>
        /// 垂直电机复位
        /// </summary>
        public bool VerticalMotorResetWait(CustomProtocol custom, int waitTime)
        {
            custom.commandType = Enums.VerticalMotorReset;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateVerticalMotorResetCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 垂直电机绝对运动
        /// </summary>
        /// <param name="custom">指令对象</param>
        /// <param name="waitTime">电机运动等待时间</param>
        /// <param name="currentVer">垂直电机目标位置</param>
        /// <param name="currentHor">当前水平电机位置</param>
        /// <param name="pictureId">图片编号</param>
        /// <param name="well">当前well</param>
        /// <param name="focal">当前层数</param>
        public bool VerticalMotorAbsoluteWait(CustomProtocol custom, int waitTime, int currentVer, int currentHor, int pictureId, int well, int focal)
        {
            custom.commandType = Enums.VerticalMotorAbsolute;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.VerticalMotorPulse = currentVer;
            custom.HorizontalMotorPulse = currentHor;
            custom.pictureId = pictureId;
            custom.well = well;
            custom.focal = focal;
            custom.CreateVerticalMotorAbsoluteMovementCommand(currentVer);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 垂直电机正向运动
        /// </summary>
        public bool VerticalMotorForwardWait(CustomProtocol custom, int waitTime,int newValue)
        {
            custom.commandType = Enums.VerticalMotorForward;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateVerticalMotorForwardCommand(newValue);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 垂直电机反向运动
        /// </summary>
        public bool VerticalMotorBackwardWait(CustomProtocol custom, int waitTime, int newValue)
        {
            custom.commandType = Enums.VerticalMotorBackward;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateVerticalMotorBackwardCommand(newValue);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }
        #endregion

        #region 控制
        /// <summary>
        /// 舱室补气
        /// </summary>
        /// <param name="custom"></param>
        public bool HouseAerationWait(CustomProtocol custom)
        {
            custom.commandType = Enums.HouseAeration;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateHouseAerationCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            return custom.IsSuccess;
        }

        /// <summary>
        /// 舱室排气
        /// </summary>
        /// <param name="custom"></param>
        public bool HouseVentWait(CustomProtocol custom)
        {
            custom.commandType = Enums.HouseVent;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateHouseVentCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            return custom.IsSuccess;
        }

        /// <summary>
        /// 缓冲瓶补气
        /// </summary>
        /// <param name="custom"></param>
        public bool BufferBottleAerationWait(CustomProtocol custom)
        {
            custom.commandType = Enums.BufferBottleAeration;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateBufferBottleAerationCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            return custom.IsSuccess;
        }

        /// <summary>
        /// 打开舱室进气阀
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        public bool OpenIntakeValveWait(CustomProtocol custom, int waitTime)
        {
            custom.commandType = Enums.OpenIntakeValve;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateOpenIntakeValveCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 关闭舱室进气阀
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        public bool CloseIntakeValveWait(CustomProtocol custom, int waitTime)
        {
            custom.commandType = Enums.CloseIntakeValve;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateCloseIntakeValveCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 打开舱室排气阀
        /// </summary>
        /// <param name="custom"></param>
        public bool OpenExhaustValveWait(CustomProtocol custom, int waitTime)
        {
            custom.commandType = Enums.OpenExhaustValve;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateOpenExhaustValveCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
            return custom.IsSuccess;
        }

        /// <summary>
        /// 关闭排气阀
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="waitTime"></param>
        public void CloseExhaustValveWait(CustomProtocol custom, int waitTime)
        {
            custom.commandType = Enums.CloseExhaustValve;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateCloseExhaustValveCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (waitTime > 0)
            {
                Thread.Sleep(waitTime);
                AddMessageInfoEvent?.Invoke($"等待{waitTime}毫秒");
            }
        }

        /// <summary>
        /// 打开LEd灯
        /// </summary>
        /// <param name="custom"></param>
        public void OpenLEDWait(CustomProtocol custom)
        {
            custom.commandType = Enums.OpenLED;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateOpenLEDCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
        }

        /// <summary>
        /// 关闭Led灯
        /// </summary>
        /// <param name="custom"></param>
        public void CloseLEDWait(CustomProtocol custom)
        {
            custom.commandType = Enums.CloseLED;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateCloseLEDCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
        }
        #endregion

        #region 参数

        /// <summary>
        /// 读取TL仪器编号
        /// </summary>
        public int ReadTLNumWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadTLNum;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadTLNumCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 获取CCDSN
        /// </summary>
        public int GetCCDSNWait(CustomProtocol custom)
        {
            custom.commandType = Enums.GetCCDSN;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateGetModuleCommand();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 读E方-->水平电机位置
        /// </summary>
        public int ReadEEPROMhoriMtWellHorHorWait(CustomProtocol custom, int horIndex)
        {
            custom.commandType = Enums.ReadEEPROMhoriMtWellHor;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadEEPROMhoriMtWellHoriPos(horIndex);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 写E方-->水平电机位置
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="newValue"></param>
        public void WriteEEPROMhoriMtWellHorHorWait(CustomProtocol custom,int wellSn, int newValue)
        {
            custom.commandType = Enums.WriteEEPROMhoriMtWell1HoriPos;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateWriteEEPROMhoriMtWellHoriPos(wellSn,newValue);
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return;
            return;
        }

        /// <summary>
        /// 读E方-->垂直电机清晰位置
        /// </summary>
        /// <returns></returns>
        public int ReadEEPROMvertMtStartPulseWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadEEPROMvertMtStartPulse;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadEEPROMvertMtStartPulse(1);
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 读E方-->垂直电机间隔脉冲
        /// </summary>
        /// <returns></returns>
        public int ReadEEPROMvertMtScanPluseWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadEEPROMvertMtScanPluse;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateReadEEPROMvertMtScanPluse();
            Enqueue(custom);//断层扫描间隔数
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 写E方-->垂直电机间隔脉冲
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="newValue"></param>
        public void WriteEEPROMvertMtScanPluseWait(CustomProtocol custom, int newValue)
        {
            custom.commandType = Enums.WriteEEPROOpenIntakeTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateWriteEEPROMvertMtScanPluse(newValue);
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return;
            return;
        }


        /// <summary>
        /// 读E方-->舱室进气阀打开时间
        /// </summary>
        /// <returns></returns>
        public int ReadEEPROOpenIntakeTimeWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadEEPROOpenIntakeTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateReadEEPROOpenIntakeTimeCommand();
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 写E方-->舱室进气阀打开时间
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="newValue"></param>
        public void WriteEEPROOpenIntakeTimeWait(CustomProtocol custom,int newValue)
        {
            custom.commandType = Enums.WriteEEPROOpenIntakeTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateWriteEEPROOpenIntakeTimeCommand(newValue);
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return;
            return;
        }

        /// <summary>
        /// 写E方-->舱室排气阀打开时间
        /// </summary>
        /// <param name="custom"></param>
        /// <param name="newValue"></param>
        public void WriteEEPROOpenVentTimeWait(CustomProtocol custom, int newValue)
        {
            custom.commandType = Enums.WriteEEPROOpenVentTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateWriteEEPROOpenVentTimeCommand(newValue);
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return;
            return;
        }

        /// <summary>
        /// 读E方-->舱室排气阀打开时间
        /// </summary>
        /// <returns></returns>
        public int ReadEEPROMVentWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadEEPROOpenVentTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateReadEEPROMVentNum();
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }


        /// <summary>
        /// 读E方-->缓冲瓶进气阀打开时间
        /// </summary>
        /// <returns></returns>
        public int ReadEEPROOpenIntakeTimeBufferWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadEEPROOpenIntakeTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateReadEEPROOpenIntakeTimeBufferCommand();
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }

        /// <summary>
        /// 写E方-->缓冲瓶进气阀打开时间
        /// </summary>
        /// <returns></returns>
        public void WriteEEPROOpenIntakeTimeBufferWait(CustomProtocol custom,int newValue)
        {
            custom.commandType = Enums.WriteEEPROOpenIntakeTime;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateWriteEEPROOpenIntakeTimeBufferCommand(newValue);
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return;
            return; 
        }

        /// <summary>
        /// 写E方-->灯光亮度
        /// </summary>
        /// <returns></returns>
        public void WriteEEPROMLightNumWait(CustomProtocol custom, int newValue)
        {
            custom.commandType = Enums.WriteLightNum;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateWriteEEPROMLightNum(newValue);
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return;
            return;
        }

        /// <summary>
        /// 读E方-->灯光亮度
        /// </summary>
        /// <returns></returns>
        public int ReadEEPROMLightNumWait(CustomProtocol custom)
        {
            custom.commandType = Enums.LightNum;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.IsWaitOne = true;
            custom.CreateReadEEPROMLightNum();
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1;
            return Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
        }


        /// <summary>
        /// 读E方-->下加热板目标温度
        /// </summary>
        /// <returns></returns>
        public decimal ReadTargetTempWait(CustomProtocol custom)
        {
            custom.commandType = Enums.ReadTargetTemp;
            custom.logDateTime = DateTime.Now;
            custom.commandNumber = commandNumber++;
            custom.CreateReadTargetTemp();
            custom.IsWaitOne = true;
            Enqueue(custom);
            taskAutoResetEvent.WaitOne();
            if (!custom.IsSuccess) return -1m;
            var num = Analysiser.ParseEEPROMPulse(custom.receivedBuffer);
            return Math.Round(num / 100.00m, 2, MidpointRounding.AwayFromZero);
        }
        #endregion

        #region 调试模式
        #endregion
    }
}