using log4net;
using log4net.Repository.Hierarchy;
using NetTaste;
using Prism.Events;
using Prism.Ioc;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Configuration;
using System.IO.Ports;
using System.Linq;
using System.Reflection.Metadata;
using System.Speech.Synthesis;
using System.Text;
using System.Threading.Channels;
using System.Threading.Tasks;
using System.Timers;
using System.Windows;
using System.Windows.Markup;
using System.Windows.Media.Animation;
using Unity;
using DM_Weight.msg;
using DM_Weight.Views;
using System.Reflection;
using DM_Weight.HIKVISION;
using PreviewDemo;
using System.Runtime.InteropServices;
using DM_Weight.Common;
using System.Net;
using System.Text.RegularExpressions;

namespace DM_Weight.Port
{
    public class PortUtil
    {
        private readonly ILog logger = LogManager.GetLogger(typeof(PortUtil));
        // 抽屉串口
        public SerialPort drawerSerial;
        // can总线串口
        public SerialPort canBusSerial;

        // 条码枪串口
        public SerialPort scanCodeSerial;

        // 冰箱串口
        //public SerialPort fridgeSerial;


        // 抽屉串口协议232 | 485
        private int _drawerProtocol = Convert.ToInt32(ConfigurationManager.AppSettings["DrawerProtocol"]);
        // can总线耗材板地址
        private int _doorAddr = Convert.ToInt32(ConfigurationManager.AppSettings["DoorAddr"]);
        // 储物箱地址
        private int _storageBoxAddr = Convert.ToInt32(ConfigurationManager.AppSettings["StorageBoxAddr"]);

        // can总线串口是否存在
        public bool _canBusExsit = Convert.ToBoolean(ConfigurationManager.AppSettings["CanBusExsit"]);

        // 当前操作的抽屉号
        public int DrawerNo { get; set; }
        // 当前操作的库位号列表
        public int[] ColNos { get; set; } = new int[] { };

        // 当前操作的窗口
        public string WindowName { get; set; }
        // 取药操作的窗口名【处方取药、抽屉取药、自选取药、调拨出库】
        private string[] TakeNames = new string[] { "DrawerTakeDrugWindow", "OrderTakeDrugWindow", "SelfTakeDrugWindow", "InvoiceTakeDrugWindow" };
        // 加药操作的窗口名【自选加药、抽屉加药、还药】
        private string[] AddNames = new string[] { "SelfAddWindow", "ReturnDrugWindow", "ReturnDrug1Window", "DrawerAddDrugWindow" };
        // 盘点操作的窗口名【盘点】
        private string[] CheckNames = new string[] { "CheckStockWindow" };
        // 归还空瓶操作的窗口名【盘点】
        private string[] ReturnEmptyNames = new string[] { "ReturnEmptyWindow" };

        public int BoardType { get; set; } = 1;
        public int DrawerType { get; set; } = 1;

        private int[] BeforeQuantity { get; set; } = new int[] { };
        private int[] AfterQuantity { get; set; } = new int[] { };

        // 整体流程状态
        private int statue { get; set; } = 0;


        // 是否正在操作中
        public bool Operate { get; set; }

        //冰箱是否正在操作中
        public bool FridgeOperate { get; set; }

        public DateTime dateTime { get; set; } = DateTime.Now;

        public async void ResetData()
        {
            logger.Info($"重新设置串口数据状态【{statue}】，抽屉【{DrawerNo}】");
            if (!"HomeWindow".Equals(WindowName) && statue == 1)
            {
                if (BoardType == 2)
                {
                    // 灭灯
                    AllLightOff();
                }
                if (BoardType == 3)
                {
                    // 失能
                    await BoxLockLightOff();
                }
                if (BoardType == 4)
                {
                    // 失能
                    CloseStorage();
                }
                if (BoardType == 6)
                {
                    // 失能
                    await BoxLockLightOff2();
                }
            }
            Operate = false;
            dateTime = DateTime.Now;
            statue = 0;
            BeforeQuantity = new int[9];
            AfterQuantity = new int[9];
            BoardType = 1;
            DrawerType = 1;
            WindowName = "";
            DrawerNo = 0;
            ColNos = new int[] { };
        }

        #region  开抽屉
        /// <summary>
        /// 打开抽屉
        /// </summary>
        /// <param name="ColNo"></param>
        /// <returns></returns>
        public async Task OpenAllDrawer()
        {
            byte[] buffer = await OpenDrawer();
            int[] r = buffer.Select(it => Convert.ToInt32(it)).ToArray();

            logger.Info($"OpenDrawer{string.Join(",", r)}");
            if (DrawerState(r))
            {
                statue = 1;
                // 返回消息  抽屉已经打开
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.DRAWEROPEN,
                    WindowName = WindowName,
                });
                logger.Info($"抽屉【{DrawerNo}】打开成功");
                // 查询抽屉状态
                await Task.Delay(200);
            }
            else
            {
                string _WindowName = WindowName;
                // 重新初始化数据
                ResetData();
                // 返回消息  抽屉打开失败
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"抽屉【{DrawerNo}】打开失败"
                });
                logger.Info($"抽屉【{DrawerNo}】打开失败");
            }
        }
        /// <summary>
        /// 查询抽屉状态
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public async Task GetAllDrawerLockState()
        {
            try
            {

                if (Operate)
                {
                    // 查询抽屉状态
                    byte[] buffer = await CheckDrawerStatus();

                    int[] r = buffer.Select(it => Convert.ToInt32(it)).ToArray();

                    logger.Info($"GetAllDrawerLockState{string.Join(",", r)}");
                    int[] subArray = new int[8];
                    for (int i = 0; i < 8; i++)
                    {
                        subArray[i] = r[2 + i];
                    }
                    bool state = subArray.All(r => r > 0);
                    if (state)
                    {
                        //抽屉全部关闭

                        string _WindowName = WindowName;
                        // 重新初始化数据
                        ResetData();
                        // 返回消息  抽屉已经关闭
                        _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                        {
                            EventType = util.EventType.DRAWERCLOSE,
                            WindowName = _WindowName,
                        });
                        logger.Info($"抽屉【{DrawerNo}】已关闭");
                    }
                    else
                    {
                        // 继续监听抽屉状态
                        await Task.Delay(200);
                        GetAllDrawerLockState();
                    }

                }

            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"GetDrawerStatus异常：{ex.Message}"
                });
                logger.Info($"GetDrawerStatus异常：{ex.Message}");
            }
        }
        #endregion
        public async void Start()
        {

            logger.Info($"进行抽屉操作抽屉号【{DrawerNo}】类型【{BoardType}】库位【{string.Join(",", ColNos)}】窗口【{WindowName}】");
            Operate = true;
            //开始录像
            //_chkFunction.HIKStartDVRRecord();
            logger.Info($"时间:{DateTime.Now}");
            try
            {
                // 储物箱直接开
                if (BoardType == 4)
                {
                    byte[] result = await OpenStorage();

                    int[] r = result.Select(it => Convert.ToInt32(it)).ToArray();
                    if (r[4] != 0)
                    {
                        logger.Info($"储物箱使能成功");
                        // 查询锁状态
                        GetBackDoorState();
                    }
                    else
                    {
                        string _WindowName = WindowName;
                        // 重新初始化数据
                        ResetData();
                        // 指令发送错误，未打开
                        // 返回消息  抽屉打开失败
                        _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                        {
                            EventType = util.EventType.OPENERROR,
                            WindowName = WindowName,
                            Message = "储物箱使能失败"
                        });
                        logger.Info($"储物箱使能失败");
                    }
                }
                else
                {
                    // 外置抽屉
                    if (DrawerType == 3)
                    {
                        if (BoardType == 2)
                        {
                            byte[] buffer = await OpenRecover();
                            int[] r = buffer.Select(it => Convert.ToInt32(it)).ToArray();
                            if ((ColNos[0] > 3 && r[4] == 1) || (ColNos[0] < 4 && r[3] == 1))
                            {

                                // 告诉前台打开成功
                                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                                {
                                    EventType = util.EventType.DRAWEROPEN,
                                    WindowName = WindowName,
                                });
                                logger.Info($"回收箱打开成功");

                                // 查询是否关闭状态
                                GeRecoverStatus();
                            }
                            else
                            {
                                string _WindowName = WindowName;
                                // 重新初始化数据
                                ResetData();
                                // 返回消息开启失败
                                // 返回消息  抽屉打开失败
                                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                                {
                                    EventType = util.EventType.OPENERROR,
                                    WindowName = WindowName,
                                    Message = "回收箱打开失败"
                                });
                                logger.Info($"回收箱打开失败");
                            }
                        }
                    }
                    // 内置抽屉
                    else
                    {
                        if (BoardType == 2)
                        {
                            byte[] quantity = await CheckQuantityByDrawer();
                            BeforeQuantity = quantity.Select(it => Convert.ToInt32(it)).ToArray().Skip(3).Take(9).ToArray();
                            logger.Info($"BeforeQuantity{string.Join(",", BeforeQuantity)}");
                        }
                        if (BoardType == 6)
                        {
                            int[] quantity = await CheckQuantityByAddr2();
                            BeforeQuantity = quantity.Select(it => Convert.ToInt32(it)).ToArray();
                            logger.Info($"BeforeQuantity{string.Join(",", BeforeQuantity)}");
                        }


                        byte[] buffer = await OpenDrawer();
                        int[] r = buffer.Select(it => Convert.ToInt32(it)).ToArray();

                        logger.Info($"OpenDrawer{string.Join(",", r)}");
                        if (DrawerState(r))
                        {
                            statue = 1;
                            // 是不是单支抽屉
                            if (BoardType == 2)
                            {
                                // 取药
                                if (Array.IndexOf(TakeNames, WindowName) > -1)
                                {
                                    // 有药位置亮灯
                                    await HasLightOnByCol();
                                }
                                // 加药
                                if (Array.IndexOf(AddNames, WindowName) > -1)
                                {
                                    // 无药位置亮灯
                                    await NoLightOnByCol();
                                }
                                // 盘点
                                if (Array.IndexOf(CheckNames, WindowName) > -1)
                                {
                                    // 不亮灯
                                }
                                // 空瓶
                                if (Array.IndexOf(ReturnEmptyNames, WindowName) > -1)
                                {
                                    // 无药位置亮灯
                                    await NoLightOnByCol();
                                }
                            }
                            // 药盒
                            if (BoardType == 3)
                            {
                                // 药盒指示灯使能
                                await BoxLockLightOn();
                            }
                            // 药盒
                            if (BoardType == 35)
                            {
                                // 药盒带屏幕
                                await OpenBox();
                            }
                            if (BoardType == 6)
                            {
                                // 药盒指示灯使能
                                await BoxLockLightOn2();
                            }
                            // 返回消息  抽屉已经打开
                            _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                            {
                                EventType = util.EventType.DRAWEROPEN,
                                WindowName = WindowName,
                            });
                            logger.Info($"抽屉【{DrawerNo}】打开成功");
                            // 查询抽屉状态
                            await Task.Delay(200);
                            GetDrawerStatus();

                        }
                        else
                        {
                            string _WindowName = WindowName;
                            // 重新初始化数据
                            ResetData();
                            // 返回消息  抽屉打开失败
                            _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                            {
                                EventType = util.EventType.OPENERROR,
                                WindowName = WindowName,
                                Message = $"抽屉【{DrawerNo}】打开失败"
                            });
                            logger.Info($"抽屉【{DrawerNo}】打开失败");
                        }
                    }

                }
            }
            catch (Exception ex)
            {
                string _WindowName = WindowName;
                // 重新初始化数据
                ResetData();
                // 返回消息  抽屉打开失败
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = _WindowName,
                    Message = $"操作异常{ex.Message}"
                });
                logger.Info(ex.Message);
            }

        }

        public async void GetDrawerStatus()
        {
            try
            {

                if (Operate)
                {
                    // 查询抽屉状态
                    byte[] buffer = await CheckDrawerStatus();

                    int[] r = buffer.Select(it => Convert.ToInt32(it)).ToArray();

                    logger.Info($"GetDrawerStatus{string.Join(",", r)}");
                    // 抽屉没有关闭
                    if (DrawerState(r))
                    {
                        if (BoardType == 2)
                        {
                            // 继续查询抽屉药品数量
                            // 查询抽屉药品数量
                            byte[] quantity = await CheckQuantityByDrawer();
                            AfterQuantity = quantity.Select(it => Convert.ToInt32(it)).ToArray().Skip(3).Take(9).ToArray();
                            logger.Info($"AfterQuantity{string.Join(",", AfterQuantity)}");
                            int[] Quantitys = new int[BeforeQuantity.Length];
                            for (int i = 0; i < BeforeQuantity.Length; i++)
                            {
                                // 取药
                                if (Array.IndexOf(TakeNames, WindowName) > -1)
                                {
                                    Quantitys[i] = BeforeQuantity[i] - AfterQuantity[i];
                                }
                                // 加药
                                if (Array.IndexOf(AddNames, WindowName) > -1)
                                {
                                    Quantitys[i] = AfterQuantity[i] - BeforeQuantity[i];
                                }
                                // 盘点
                                if (Array.IndexOf(CheckNames, WindowName) > -1)
                                {
                                    Quantitys[i] = AfterQuantity[i] - BeforeQuantity[i];
                                }
                                // 空瓶
                                if (Array.IndexOf(CheckNames, WindowName) > -1)
                                {
                                    Quantitys[i] = AfterQuantity[i] - BeforeQuantity[i];
                                }

                            }
                            // 告诉前台数据变化
                            _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                            {
                                EventType = util.EventType.UPDATEQUANTITY,
                                WindowName = WindowName,
                                Quantitys = Quantitys
                            });
                            logger.Info($"单支板数量变化【{string.Join(",", Quantitys)}】");

                        }
                        if (BoardType == 6)
                        {
                            // 继续查询抽屉药品数量
                            // 查询抽屉药品数量
                            int[] quantity = await CheckQuantityByAddr2();
                            AfterQuantity = quantity.Select(it => Convert.ToInt32(it)).ToArray();
                            logger.Info($"AfterQuantity{string.Join(",", AfterQuantity)}");
                            int[] Quantitys = new int[BeforeQuantity.Length];
                            for (int i = 0; i < BeforeQuantity.Length; i++)
                            {
                                // 取药
                                if (Array.IndexOf(TakeNames, WindowName) > -1)
                                {
                                    Quantitys[i] = BeforeQuantity[i] - AfterQuantity[i];
                                }
                                // 加药
                                if (Array.IndexOf(AddNames, WindowName) > -1)
                                {
                                    Quantitys[i] = AfterQuantity[i] - BeforeQuantity[i];
                                }
                                // 盘点
                                if (Array.IndexOf(CheckNames, WindowName) > -1)
                                {
                                    Quantitys[i] = AfterQuantity[i] - BeforeQuantity[i];
                                }
                                // 空瓶
                                if (Array.IndexOf(CheckNames, WindowName) > -1)
                                {
                                    Quantitys[i] = AfterQuantity[i] - BeforeQuantity[i];
                                }

                            }
                            // 告诉前台数据变化
                            _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                            {
                                EventType = util.EventType.UPDATEQUANTITY,
                                WindowName = WindowName,
                                Quantitys = Quantitys
                            });
                            logger.Info($"单支板数量变化【{string.Join(",", Quantitys)}】");

                        }
                        // 继续监听抽屉状态
                        await Task.Delay(200);
                        GetDrawerStatus();
                    }
                    else
                    {
                        statue = 2;
                        if (BoardType == 2)
                        {
                            // 关灯
                            AllLightOff();

                        }
                        // 药盒
                        if (BoardType == 3)
                        {
                            // 药盒指示灯失能
                            await BoxLockLightOff();
                        }
                        if (BoardType == 6)
                        {
                            // 药盒指示灯使能
                            await BoxLockLightOff2();
                        }
                        string _WindowName = WindowName;
                        // 重新初始化数据
                        ResetData();
                        // 返回消息  抽屉已经关闭
                        _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                        {
                            EventType = util.EventType.DRAWERCLOSE,
                            WindowName = _WindowName,
                        });
                        logger.Info($"抽屉【{DrawerNo}】已关闭");
                    }
                }

            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"GetDrawerStatus异常：{ex.Message}"
                });
                logger.Info($"GetDrawerStatus异常：{ex.Message}");
            }
        }


        public async void GeRecoverStatus()
        {
            if (Operate)
            {
                byte[] buffer = await CheckRecoverStatus();
                int[] r = buffer.Select(it => Convert.ToInt32(it)).ToArray();

                logger.Info($"GeRecoverStatus{string.Join(",", r)}");

                // 回收箱关闭成功
                if ((ColNos[0] > 3 && r[4] == 0) || (ColNos[0] < 4 && r[3] == 0))
                {
                    logger.Info($"回收箱关闭");
                    // 查询数量
                    byte[] bytes = await CheckRecoverQuantity();

                    int[] r1 = bytes.Select(it => Convert.ToInt32(it)).ToArray();
                    // 返回消息库位关闭，放入空瓶数量
                    int[] quantitys = r1.Skip(3).Take(3).ToArray();
                    int index = ColNos[0] % 3 > 0 ? ColNos[0] % 3 - 1 : 2;

                    // 指定库位放入的药品数量
                    int InCount = quantitys[index];
                    string _WindowName = WindowName;
                    // 重新初始化数据
                    ResetData();
                    _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                    {
                        EventType = util.EventType.DRAWERCLOSE,
                        Quantitys = new int[] { InCount },
                        WindowName = WindowName,
                    });

                    logger.Info($"回收板数量变化【{string.Join(",", quantitys)}】");
                }
                else
                {
                    // 查询是否关闭状态
                    await Task.Delay(200);
                    GeRecoverStatus();
                }
            }
        }

        public async void GetBackDoorState()
        {
            try
            {
                if (Operate)
                {
                    byte[] result = await BackDoorState();

                    int[] r = result.Select(it => Convert.ToInt32(it)).ToArray();
                    int[] lockStates = CheckStorageStatus(r.Skip(3).Take(2).ToArray());
                    int[] lightStates = CheckStorageStatus(r.Skip(5).Take(2).ToArray());

                    // 锁处于关闭状态
                    if (lockStates[_storageBoxAddr - 1] == 0)
                    {
                        // 锁还未打开过
                        if (statue == 0)
                        {
                            // 指示灯不闪烁了，说明规定时间内没有开锁，需要给前台提示
                            if (lightStates[_storageBoxAddr - 1] == 0)
                            {
                                // 打开失败
                                logger.Info($"储物箱指示灯不闪烁，使能过期");
                            }
                            else
                            {
                                // 灯在闪烁继续监听状态
                                GetBackDoorState();
                            }
                        }
                        else if (statue == 1)
                        {

                            // 锁是打开状态现在关闭了，说明操作完成了,告诉前台锁已关闭
                            statue = 2;

                            string _WindowName = WindowName;
                            // 重新初始化数据
                            ResetData();
                            _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                            {
                                EventType = util.EventType.DRAWERCLOSE,
                                WindowName = _WindowName,
                            });
                            logger.Info($"储物箱关闭");
                        }
                    }
                    // 锁处于打开状态
                    if (lockStates[_storageBoxAddr - 1] == 1)
                    {
                        // 锁还未打开过，说明打开成功了
                        if (statue == 0)
                        {
                            statue = 1;
                            // 告诉前台打开成功
                            _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                            {
                                EventType = util.EventType.DRAWEROPEN,
                                WindowName = WindowName,
                            });
                            logger.Info($"储物箱打开成功");
                        }
                        // 灯在闪烁继续监听状态
                        GetBackDoorState();
                    }
                }


            }
            catch (Exception ex)
            {
                logger.Info($"GetBackDoorState异常{ex.Message}");
            }
        }


        private readonly IEventAggregator _eventAggregator;
        //private CHKFunction _chkFunction;
        public PortUtil(IEventAggregator eventAggregator)
        {
            _eventAggregator = eventAggregator;
            try
            {
                string DrawerPortPath = ConfigurationManager.AppSettings["DrawerPortPath"];
                logger.Info($"打开抽屉串口【{DrawerPortPath}】");
                drawerSerial = new SerialPort(DrawerPortPath, 9600, Parity.None, 8);
                drawerSerial.Open();
                logger.Info($"抽屉串口打开结果【{drawerSerial.IsOpen}】");
            }
            catch (Exception e)
            {
                logger.Error("抽屉串口打开错误" + e.Message);
            }

            try
            {
                string ScanCodePortPath = ConfigurationManager.AppSettings["ScanCodePortPath"];
                logger.Info($"打开条码枪串口【{ScanCodePortPath}】");
                scanCodeSerial = new SerialPort(ScanCodePortPath, 9600, Parity.None, 8);
                scanCodeSerial.DataReceived += (object sender, System.IO.Ports.SerialDataReceivedEventArgs e) =>
                {
                    string code = scanCodeSerial.ReadExisting();
                    _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                    {
                        EventType = util.EventType.CODESCAN,
                        Code = code,
                    });
                };
                scanCodeSerial.Open();
                logger.Info($"条码枪串口打开结果【{scanCodeSerial.IsOpen}】");
            }
            catch (Exception e)
            {
                logger.Error("条码枪串口打开错误" + e.Message);
            }
            //try
            //{
            //    string FridgePortPath = ConfigurationManager.AppSettings["FridgePortPath"];
            //    logger.Info($"打开冰箱串口【{FridgePortPath}】");
            //    fridgeSerial = new SerialPort(FridgePortPath, 9600, Parity.None, 8);
            //    fridgeSerial.Open();
            //    logger.Info($"冰箱串口打开结果【{fridgeSerial.IsOpen}】");
            //}
            //catch (Exception e)
            //{
            //    logger.Error("冰箱串口打开错误" + e.Message);
            //}
            if (_canBusExsit)
            {
                try
                {
                    string CanBusPortPath = ConfigurationManager.AppSettings["CanBusPortPath"];
                    logger.Info($"打开can总线串口【{CanBusPortPath}】");
                    canBusSerial = new SerialPort(CanBusPortPath, 57600, Parity.None, 8);
                    canBusSerial.Open();
                    logger.Info($"can总线串口打开结果【{canBusSerial.IsOpen}】");
                }
                catch (Exception e)
                {
                    logger.Error("can总线串口打开错误" + e.Message);
                }

            }
            //_chkFunction = chkFunction;
        }


        private byte[] GetBufferByPort(SerialPort serialPort, int length, int timeout)
        {
            byte[] buffer = new byte[length];
            // try
            // {
            int _length = 0;
            DateTime start = DateTime.Now;
            DateTime end = DateTime.Now;
            while (_length != length && end.Subtract(start).TotalMilliseconds < timeout)
            {
                _length = serialPort.BytesToRead;
                end = DateTime.Now;
            }
            if (_length != length)
            {
                throw new TimeoutException($"串口【{serialPort.PortName}】交互超时");
            }
            serialPort.Read(buffer, 0, length);
            // }
            // catch (Exception ex)
            // {
            // logger.Error($"GetBufferByPort：{ex.Message}");
            // }
            return buffer;
        }
        private Task<byte[]> GetBufferByPort(SerialPort serialPort, int length)
        {

            return Task.Run(() => GetBufferByPort(serialPort, length, 3000));
        }


        public static SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer();
        public void SpeakAsync(string textinfo)
        {
            speechSynthesizer.SpeakAsync(textinfo);
        }



        #region 抽屉串口操作
        // 打开抽屉
        public async Task<byte[]> OpenDrawer()
        {
            drawerSerial.DiscardInBuffer();
            byte[] buffer = new byte[] { 0xaa, 0x41, (byte)DrawerNo, 0xee };
            if (_drawerProtocol == 485)
            {
                if (DrawerNo > 8)
                {
                    buffer = new byte[] { 0xaa, 0x21, (byte)(DrawerNo - 8), 0xee };
                }
                else
                {
                    buffer = new byte[] { 0xaa, 0x11, (byte)DrawerNo, 0xee };
                }

            }
            logger.Info($"打开抽屉，串口数据：{Convert.ToHexString(buffer)}");
            drawerSerial.Write(buffer, 0, 4);

            return await GetBufferByPort(drawerSerial, 11);
        }

        private bool DrawerState(int[] r)
        {
            int index = DrawerNo > 8 ? DrawerNo - 7 : DrawerNo + 1;
            return r[index] == 0;
        }

        // 查询抽屉状态
        public async Task<byte[]> CheckDrawerStatus()
        {
            drawerSerial.DiscardInBuffer();
            byte[] buffer = new byte[] { 0xaa, 0x42, 0xee };
            if (_drawerProtocol == 485)
            {
                if (DrawerNo > 8)
                {
                    buffer = new byte[] { 0xaa, 0x22, 0xee };
                }
                else
                {
                    buffer = new byte[] { 0xaa, 0x12, 0xee };
                }

            }

            logger.Info($"查询抽屉状态，串口数据：{Convert.ToHexString(buffer)}");
            drawerSerial.Write(buffer, 0, 3);

            return await GetBufferByPort(drawerSerial, 11);
        }
        #endregion

        #region can总线串口操作
        #region 耗材板操作
        // 后门状态
        public async Task<byte[]> BackDoorState()
        {

            canBusSerial.DiscardInBuffer();
            byte[] buffer = new byte[] { 0xaa, (byte)(_doorAddr), 0x02, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);

            return await GetBufferByPort(canBusSerial, 8);

        }
        // 打开电控门储物箱（有灯使能）
        public async Task<byte[]> OpenStorage()
        {
            canBusSerial.DiscardInBuffer();
            byte[] buffer = new byte[] { 0xaa, (byte)(_doorAddr), 0x01, (byte)_storageBoxAddr, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);


            return await GetBufferByPort(canBusSerial, 8);
        }
        // 关闭电控门储物箱（有灯失能）
        public void CloseStorage()
        {
            byte[] buffer = new byte[] { 0xaa, (byte)(_doorAddr), 0x04, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 打开普通储物箱（无灯）
        public void OpenStorageBox()
        {
            byte[] buffer = new byte[] { 0xaa, (byte)(_storageBoxAddr), 0x03, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 关闭普通储物箱（无灯）
        public void CloseStorageBox()
        {
            byte[] buffer = new byte[] { 0xaa, (byte)(_storageBoxAddr), 0x04, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }

        private int[] CheckStorageStatus(int[] data)
        {
            int a = data[0];
            int b = data[1];
            int[] intA = Decimal2Chunks(a);
            int[] intB = Decimal2Chunks(b);
            int[] r = new int[intA.Length + intB.Length];
            Array.Copy(intA, 0, r, 0, intA.Length);
            Array.Copy(intB, 0, r, intA.Length, intB.Length);
            return r;
        }
        private int[] Decimal2Chunks(int d)
        {
            string s = Convert.ToString(d, 2);
            int[] chars = new int[8];
            char[] schar = s.ToCharArray();
            Array.Reverse(schar);
            int[] iArray = Array.ConvertAll(schar, c => (int)Char.GetNumericValue(c));
            int[] addArray = new int[8 - iArray.Length];
            if (iArray.Length < 8)
            {
                for (int i = 0; i < 8 - iArray.Length; i++)
                {
                    addArray[i] = 0;
                }
                chars = iArray.Concat(addArray).ToArray();
            }
            else
            {
                chars = iArray[0..iArray.Length];
            }
            return chars;
            //List<int> t = s.Split().Select(it => Convert.ToInt32(it)).Reverse().ToList();
            //while (t.Count < 8)
            //{
            //    t.Add(0);
            //}
            //return t.ToArray();
        }

        #endregion

        #region 单支操作
        // 以抽屉为单位获取抽屉内所有库位的药品数量
        public async Task<byte[]> CheckQuantityByDrawer()
        {
            canBusSerial.DiscardInBuffer();

            byte[] buffer = new byte[] { 0xaa, (byte)(0xf0 + DrawerNo), 0x01, 0x00, 0x00, 0x00, 0x00, 0xee };

            logger.Info($"单支板发送库位数量查询【{string.Join(",", buffer)}】");
            canBusSerial.Write(buffer, 0, 8);

            return await GetBufferByPort(canBusSerial, 13);
        }
        // 获取单个单支板药品数量
        public async Task<byte[]> CheckQuantityByCol(int DrawerNo, int colNo)
        {
            canBusSerial.DiscardInBuffer();

            var channel = Convert.ToInt32((DrawerNo * 10 + colNo).ToString(), 16);
            byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x08, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);

            return await GetBufferByPort(canBusSerial, 8);

        }
        // 以抽屉为单位有药位置亮灯
        public void HasLightOnByDrawer()
        {
            byte[] buffer = new byte[] { 0xaa, (byte)(0xf0 + DrawerNo), 0x02, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 以抽屉为单位无药位置亮灯
        public void NoLightOnByDrawer()
        {
            byte[] buffer = new byte[] { 0xaa, (byte)(0xf0 + DrawerNo), 0x03, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 以抽屉为单位灭灯
        public void LightOffByDrawer()
        {
            byte[] buffer = new byte[] { 0xaa, (byte)(0xf0 + DrawerNo), 0x06, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 以单支板为单位有药位置亮灯
        public async Task HasLightOnByCol()
        {

            for (int i = 0; i < ColNos.Length; i++)
            {

                var channel = Convert.ToInt32((DrawerNo * 10 + ColNos[i]).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x0a, 0x00, 0x00, 0x00, 0x00, 0xee };
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(TimeSpan.FromMilliseconds(20));
            }

        }
        // 以单支板为单位无药位置亮灯
        public async Task NoLightOnByCol()
        {
            for (int i = 0; i < ColNos.Length; i++)
            {
                var channel = Convert.ToInt32((DrawerNo * 10 + ColNos[i]).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x0b, 0x00, 0x00, 0x00, 0x00, 0xee };
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(TimeSpan.FromMilliseconds(20));
            }
        }
        // 广播灭灯
        public void AllLightOff()
        {
            byte[] buffer = new byte[] { 0xaa, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        #endregion

        #region 药盒操作
        // 指定药盒指示灯开启使能开锁
        public async Task BoxLockLightOn()
        {
            for (int i = 0; i < ColNos.Length; i++)
            {

                var channel = Convert.ToInt32((DrawerNo * 10 + ColNos[i]).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x03, 0x00, 0x00, 0x00, 0x00, 0xee };
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(TimeSpan.FromMilliseconds(20));
            }
        }
        // 指定药盒指示灯开启失能开锁
        public async Task BoxLockLightOff()
        {
            for (int i = 0; i < ColNos.Length; i++)
            {
                var channel = Convert.ToInt32((DrawerNo * 10 + ColNos[i]).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x04, 0x00, 0x00, 0x00, 0x00, 0xee };
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(TimeSpan.FromMilliseconds(20));
            }
        }
        // 指定药盒状态查询
        public async Task<byte[]> BoxLockState(int ColNo)
        {
            canBusSerial.DiscardInBuffer();
            var channel = Convert.ToInt32((DrawerNo * 10 + ColNo).ToString(), 16);
            byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x02, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);

            return await GetBufferByPort(canBusSerial, 8);

        }
        // 以抽屉为单位药盒指示灯开启使能开锁
        public async Task BoxLockLightOnByDrawer()
        {
            canBusSerial.DiscardInBuffer();
            byte[] buffer = new byte[] { 0xaa, (byte)(0xf0 + DrawerNo), 0x04, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 以抽屉为单位药盒指示灯开启失能开锁
        public async Task BoxLockLightOffByDrawer()
        {
            canBusSerial.DiscardInBuffer();
            byte[] buffer = new byte[] { 0xaa, (byte)(0xf0 + DrawerNo), 0x05, 0x00, 0x00, 0x00, 0x00, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        #endregion

        #region  药盒操作
        /// <summary>
        /// 打开药盒
        /// </summary>
        /// <param name="ColNo"></param>
        /// <returns></returns>
        public async Task OpenBox()
        {
            for (int i = 0; i < ColNos.Length; i++)
            {
                int ColNo = ColNos[i];
                int[] iNum = new int[] { 4, 2, 1 };
                var colNo2 = ColNo % 3 > 0 ? (ColNo % 3) - 1 : 2;
                var bColNo = iNum[colNo2];
                decimal decolNO = (decimal)ColNo;
                var channel = Convert.ToInt32((DrawerNo * 10 + Math.Ceiling(decolNO / 3)).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 5, (byte)bColNo, 0x00, 0x00, 0x00, 0xee };
                //byte[] buffer = new byte[] { 0xaa, 0x11, 0x05,0x01, 0x00,0x00,0x00,0xee};
                logger.Info($"{Convert.ToHexString(buffer)}");
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(800);
            }

        }
        /// <summary>
        /// 查询药盒状态
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public async Task<byte[]> OpenBoxState(int ColNo)
        {
            decimal deColNo = (decimal)ColNo;
            var channel = Convert.ToInt32((DrawerNo * 10 + Math.Ceiling(deColNo / 3)).ToString(), 16);
            byte[] buffer = new byte[] { 0xaa, (byte)channel, 2, 0, 0, 0, 0, 0xee };
            canBusSerial.Write(buffer, 0, 8);
            return await GetBufferByPort(canBusSerial, 8);
        }

        #endregion

        private string trim(string text)
        {
            //此处使用了转义字符如：\',\",\\，分别表示单引号，双引号，反斜杠
            char[] TrimChar = { ' ', '-', '\'', '\"', '\\', '(', ')', '（', '）', '①', '②' };
            return text.Trim(TrimChar);
        }

        #region 2.4寸汉显屏
        // 基础数据写入方法
        public async Task WriteChannelInfo(int type, string content, int drawerNo, int colNo)
        {
            try
            {
                if (content.Length > 10)
                {
                    content = content.Substring(0, 10);
                }
                canBusSerial.DiscardInBuffer();
                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
                byte[] contentBuf = Encoding.GetEncoding("gb2312").GetBytes(trim(content));
                int channel = (drawerNo * 10 + colNo);
                if (contentBuf.Length % 2 != 0)
                {
                    Array.Resize(ref contentBuf, contentBuf.Length + 1);
                }
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 1, (byte)type, 0, 0, 0, 0xee };
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(20);
                buffer[4] = 1;
                for (int i = 0; i < contentBuf.Length; i += 2)
                {
                    buffer[5] = contentBuf[i];
                    buffer[6] = contentBuf[i + 1];
                    canBusSerial.Write(buffer, 0, 8);
                    await Task.Delay(20);
                }
                buffer[4] = 2;
                buffer[5] = 0;
                buffer[6] = 0;
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(20);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"2.4寸汉显屏异常{ex.Message}"
                });
                logger.Info($"2.4寸汉显屏异常：ex:{ex.Message}");
            }
        }

        // 清除显示内容
        public void ClearContent(int drawerNo, int colNo)
        {
            canBusSerial.DiscardInBuffer();
            int channel = (drawerNo * 10 + colNo);
            byte[] buffer = new byte[] { 0xaa, (byte)channel, 4, 0, 0, 0, 0, 0xee };
            canBusSerial.Write(buffer, 0, 8);
        }
        // 刷新显示内容
        public void ShowContent(int drawerNo, int colNo)
        {
            try
            {

                canBusSerial.DiscardInBuffer();
                int channel = (drawerNo * 10 + colNo);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 2, 0, 0, 0, 0, 0xee };
                canBusSerial.Write(buffer, 0, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"刷新显示内容异常{ex.Message}"
                });
                logger.Info($"刷新显示内容异常：ex:{ex.Message}");
            }
        }
        // 取药或者加药亮灯
        public void TakeQuantity(int drawerNo, int colNo, int quantity, int stock)
        {
            try
            {

                canBusSerial.DiscardInBuffer();
                int channel = Convert.ToInt32((drawerNo * 10 + colNo).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 6, 0, 0, 0, 0, 0xee };
                buffer[3] = (byte)(quantity >> 8);
                buffer[4] = (byte)(quantity & 0xff);
                buffer[5] = (byte)(stock >> 8);
                buffer[6] = (byte)(stock & 0xff);
                canBusSerial.Write(buffer, 0, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message}");
            }
        }
        // 写入数量
        public async Task WriteQuantity(int drawerNo, int colNo, int quantity)
        {
            try
            {
                canBusSerial.DiscardInBuffer();
                int channel = (drawerNo * 10 + colNo);
                byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x21, 0, 0, 0, 0, 0xee };
                buffer[5] = (byte)(quantity >> 8);
                buffer[6] = (byte)(quantity & 0xff);
                canBusSerial.Write(buffer, 0, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message}");
            }
        }



        #endregion

        #region 标签显示屏
        //清屏
        public void ClearContentMethod(int drawerNo, int colNo)
        {
            decimal deColNo = colNo;
            //var channel = drawerNo * 10 + Math.Ceiling(deColNo / 3);
            int[] iNum = new int[] { 3, 2, 1 };
            var colNo2 = colNo % 3 > 0 ? (colNo % 3) - 1 : 2;
            var bColNo = Convert.ToInt32((iNum[colNo2]+10).ToString(),16);
            //var index = Convert.ToInt32(((colNo % 3 == 0 ? 3 : colNo % 3)+10).ToString(),16);
            int channel = Convert.ToInt32((drawerNo * 10 + Math.Ceiling((decimal)colNo / 3)).ToString(), 16);
            byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x09, (byte)bColNo, 0,0,0, 0xee };
            canBusSerial.Write(buffer, 0, 8);
            logger.Info($"清屏指令：{Convert.ToHexString(buffer)}");
        }
        //刷新内容
        public async Task ShowContentMethod(int drawerNo, int colNo)
        {
            int channel = Convert.ToInt32((drawerNo * 10 + Math.Ceiling((decimal)colNo / 3)).ToString(), 16);
            byte[] buffer = new byte[] { 0xaa, (byte)channel, 0x0c, 0x00, 0x00, 0x00, 0x00, 0xee };
            logger.Info($"刷新内容指令：{Convert.ToHexString(buffer)}");
            canBusSerial.Write(buffer, 0, 8);
        }
        // 基础数据写入方法
        public async Task WriteChannelInfoMethod(int type, string content, int drawerNo, int colNo)
        {
            try
            {
                canBusSerial.DiscardInBuffer();
                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
                byte[] contentBuf = Encoding.GetEncoding("gb2312").GetBytes(trim(content));
                if (content.Length > 10)
                {
                    content = content.Substring(0, 10);
                }
                int channel = Convert.ToInt32((drawerNo * 10 + Math.Ceiling((decimal)colNo / 3)).ToString(), 16);
                int[] iNum = new int[] { 3, 2, 1 };
                var colNo2 = colNo % 3 > 0 ? (colNo % 3) - 1 : 2;
                var bColNo = iNum[colNo2]+160;
                //var index = (colNo % 3 == 0 ? 3 : colNo % 3)+160;
                if (contentBuf.Length % 2 != 0)
                {
                    Array.Resize(ref contentBuf, contentBuf.Length + 1);
                }
                byte[] buffer = new byte[] { 0xaa, (byte)channel, (byte)bColNo, (byte)type, 0, 0, 0, 0xee };
                canBusSerial.Write(buffer, 0, 8);
                logger.Info($"开始写标签指令：{Convert.ToHexString(buffer)}");
                await Task.Delay(30);
                buffer[4] = 1;
                for (int i = 0; i < contentBuf.Length; i += 2)
                {
                    buffer[5] = contentBuf[i];
                    buffer[6] = contentBuf[i + 1];
                    canBusSerial.Write(buffer, 0, 8);
                    logger.Info($"写标签指令：{Convert.ToHexString(buffer)}");
                    await Task.Delay(30);
                }
                buffer[4] = 2;
                buffer[5] = 0;
                buffer[6] = 0;
                canBusSerial.Write(buffer, 0, 8);
                logger.Info($"结束写标签指令：{Convert.ToHexString(buffer)}");
                await Task.Delay(30);

            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"2.4寸汉显屏异常{ex.Message}"
                });
                logger.Info($"2.4寸汉显屏异常：ex:{ex.Message}");
            }
        }

        #endregion

        #region 回收箱操作
        // 打开回收箱
        public async Task<byte[]> OpenRecover()
        {
            try
            {
                canBusSerial.DiscardInBuffer();
                byte[] buffer = new byte[] { 0xAA, 0x9A, 0x04, 0x00, 0x00, 0x00, 0x00, 0xEE };
                canBusSerial.Write(buffer, 0, 8);

                return await GetBufferByPort(canBusSerial, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message}");
                return null;
            }

        }
        // 回收箱状态查询
        public async Task<byte[]> CheckRecoverStatus()
        {
            try
            {

                canBusSerial.DiscardInBuffer();
                byte[] buffer = new byte[] { 0xAA, 0x9A, 0x03, 0x00, 0x00, 0x00, 0x00, 0xEE };
                canBusSerial.Write(buffer, 0, 8);

                return await GetBufferByPort(canBusSerial, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message}");
                return null;

            }
        }
        // 回收箱回收数量查询
        public async Task<byte[]> CheckRecoverQuantity()
        {
            try
            {
                canBusSerial.DiscardInBuffer();
                byte[] buffer = new byte[] { 0xAA, 0x9A, (byte)(ColNos[0] > 3 ? 2 : 1), 0x00, 0x00, 0x00, 0x00, 0xEE };
                //byte[] buffer = new byte[] { 0xAA, 0x9A, 01, (byte)(ColNos[0] > 3 ? 2 : 1), 0x00, 0x00, 0x00, 0xEE };
                canBusSerial.Write(buffer, 0, 8);

                return await GetBufferByPort(canBusSerial, 8);

            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message}");
                return null;
            }
        }
        #endregion

        #region 称重操作
        // 以板子为单位获取抽屉内所有库位的药品数量
        public async Task<byte[]> CheckQuantityByAddr()
        {

            canBusSerial.DiscardInBuffer();
            var channel = Convert.ToInt32((DrawerNo * 10 + 1).ToString(), 16);
            byte[] buffer = new byte[] { 0xaa, (byte)(channel), 0x28, 0x00, 0x00, 0x00, 0x00, 0xee };
            logger.Info($"称重发送库位数量查询1【{string.Join(",", buffer)}】");
            canBusSerial.Write(buffer, 0, 8);
            byte[] result1 = await GetBufferByPort(canBusSerial, 8);


            var channel2 = Convert.ToInt32((DrawerNo * 10 + 2).ToString(), 16);
            byte[] buffer2 = new byte[] { 0xaa, (byte)(channel2), 0x28, 0x00, 0x00, 0x00, 0x00, 0xee };
            logger.Info($"称重发送库位数量查询2【{string.Join(",", buffer2)}】");
            canBusSerial.Write(buffer2, 0, 8);
            byte[] result2 = await GetBufferByPort(canBusSerial, 8);

            byte[] res = new byte[6];
            Array.Copy(result1, 3, res, 0, 3);
            Array.Copy(result2, 3, res, 3, 3);

            return res;

        }

        // 以板子为单位获取抽屉内所有库位的药品数量
        public async Task<int[]> CheckQuantityByAddr2()
        {


            int[] res = new int[6];
            for (int i = 0; i < ColNos.Length; i++)
            {
                canBusSerial.DiscardInBuffer();
                var index = ColNos[i] > 3 ? 2 : 1;
                var lock1 = ColNos[i] % 3 == 0 ? 3 : ColNos[i] % 3;
                var channel = Convert.ToInt32((DrawerNo * 10 + index).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)(channel), 0x27, (byte)lock1, 0x00, 0x00, 0x00, 0xee };

                logger.Info($"称重发送库位数量查询1【{string.Join(",", buffer)}】");
                canBusSerial.Write(buffer, 0, 8);
                byte[] result = await GetBufferByPort(canBusSerial, 8);
                logger.Info($"称重发送库位数量查询1返回结果【{string.Join(",", result)}】");
                byte[] hl = result.Skip(3).Take(2).ToArray();
                int quantity = BitConverter.ToInt16(hl.Reverse().ToArray(), 0);
                res[ColNos[i] - 1] = quantity;
            }

            return res;

        }

        // 指定药盒指示灯开启使能开锁
        public async Task BoxLockLightOn2()
        {
            for (int i = 0; i < ColNos.Length; i++)
            {
                var index = ColNos[i] > 3 ? 2 : 1;
                var lock1 = ColNos[i] % 3 == 0 ? 3 : ColNos[i] % 3;
                var channel = Convert.ToInt32((DrawerNo * 10 + index).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)(channel), 0x03, (byte)lock1, 0x00, 0x00, 0x00, 0xee };
                logger.Info($"称重发送药盒使能【{string.Join(",", buffer)}】");
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(TimeSpan.FromMilliseconds(500));
            }
        }
        // 指定药盒指示灯开启失能开锁
        public async Task BoxLockLightOff2()
        {
            canBusSerial.DiscardInBuffer();
            for (int i = 0; i < ColNos.Length; i++)
            {
                var index = ColNos[i] > 3 ? 2 : 1;
                var lock1 = ColNos[i] % 3 == 0 ? 3 : ColNos[i] % 3;
                var channel = Convert.ToInt32((DrawerNo * 10 + index).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)(channel), 0x04, (byte)lock1, 0x00, 0x00, 0x00, 0xee };
                logger.Info($"称重发送药盒失能【{string.Join(",", buffer)}】");
                canBusSerial.Write(buffer, 0, 8);
                await Task.Delay(TimeSpan.FromMilliseconds(50));
            }
        }

        public async void ClearCount(int DrawerNo, int ColNo)
        {
            try
            {
                canBusSerial.DiscardInBuffer();
                var index = ColNo > 3 ? 2 : 1;
                var lock1 = ColNo % 3 == 0 ? 3 : ColNo % 3;
                var channel = Convert.ToInt32((DrawerNo * 10 + index).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)(channel), 0x25, (byte)lock1, 0x00, 0x00, 0x00, 0xee };

                logger.Info($"称重发送清空计数【{string.Join(",", buffer)}】");
                canBusSerial.Write(buffer, 0, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message},方法名：ClearCount；参数：{DrawerNo}，{ColNo}");
            }

        }

        public async void SetNumCount(int DrawerNo, int ColNo, int Quantity)
        {
            try
            {
                canBusSerial.DiscardInBuffer();
                var index = ColNo > 3 ? 2 : 1;
                var lock1 = ColNo % 3 == 0 ? 3 : ColNo % 3;
                var channel = Convert.ToInt32((DrawerNo * 10 + index).ToString(), 16);
                byte[] buffer = new byte[] { 0xaa, (byte)(channel), 0x26, (byte)lock1, 0x00, 0x00, 0x00, 0xee };


                buffer[4] = (byte)(Quantity >> 8);
                buffer[5] = (byte)(Quantity & 0xff);


                logger.Info($"称重发送数量【{string.Join(",", buffer)}】");
                canBusSerial.Write(buffer, 0, 8);
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<PortUtilEvent>().Publish(new util.DeviceMsg()
                {
                    EventType = util.EventType.OPENERROR,
                    WindowName = WindowName,
                    Message = $"操作发生异常{ex.Message}"
                });
                logger.Info($"操作发生异常：ex:{ex.Message},方法名：SetNumCount；参数：{DrawerNo}，{ColNo},{Quantity}");
            }

        }
        #endregion
        ///// <summary>
        ///// 冰箱使能
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridegOpen(int iIndex)
        //{
        //    try
        //    {
        //        fridgeSerial.DiscardInBuffer();
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] buffer = new byte[] { bAddress, 0x06, 0x10, 0xD4, 0x00, 0x01, 0x0C, 0xF2 };
        //        //byte[] buffer = new byte[] { 0x01, 0x06, 0x10, 0xD4, 0x00, 0x01 };
        //        ////获取数组CRC校验码
        //        //byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //        ////Array.Reverse(byteDate);
        //        //int dataLength = buffer.Length;
        //        //Array.Resize(ref buffer, dataLength + byteDate.Length);
        //        //for (int i = 0; i < byteDate.Length; i++)
        //        //{
        //        //    buffer[dataLength + i] = byteDate[i];
        //        //}
        //        logger.Info($"冰箱使能【{Convert.ToHexString(buffer)}】");
        //        fridgeSerial.Write(buffer, 0, 8);
        //        await Task.Delay(80);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Info($"冰箱使能发生异常：ex:{ex.Message}");
        //    }
        //    FridgeOperate = false;
        //}
        ///// <summary>
        ///// 冰箱失能
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridgeOff(int iIndex)
        //{
        //    try
        //    {
        //        fridgeSerial.DiscardInBuffer();
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] buffer = new byte[] { bAddress, 0x06, 0x10, 0xD4, 0x00, 0x00, 0xCD, 0x32 };
        //        //byte[] buffer = new byte[] { 0x01, 0x06, 0x10, 0xD4, 0x00, 0x01 };
        //        ////获取数组CRC校验码
        //        //byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //        ////Array.Reverse(byteDate);
        //        //int dataLength = buffer.Length;
        //        //Array.Resize(ref buffer, dataLength + byteDate.Length);
        //        //for (int i = 0; i < byteDate.Length; i++)
        //        //{
        //        //    buffer[dataLength + i] = byteDate[i];
        //        //}
        //        logger.Info($"冰箱失能【{Convert.ToHexString(buffer)}】");
        //        fridgeSerial.Write(buffer, 0, 8);
        //        await Task.Delay(80);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Info($"冰箱失能发生异常：ex:{ex.Message}");
        //    }
        //    FridgeOperate = false;
        //}
        ///// <summary>
        ///// 冰箱报警使能
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridgeAlarmOn(int iIndex)
        //{
        //    try
        //    {
        //        fridgeSerial.DiscardInBuffer();
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] buffer = new byte[] { bAddress, 0x06, 0x10, 0xD5, 0x00, 0x01, 0x5D, 0x32 };
        //        //byte[] buffer = new byte[] { 0x01, 0x06, 0x10, 0xD5, 0x00, 0x01 };
        //        ////获取数组CRC校验码
        //        //byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //        ////Array.Reverse(byteDate);
        //        //int dataLength = buffer.Length;
        //        //Array.Resize(ref buffer, dataLength + byteDate.Length);
        //        //for (int i = 0; i < byteDate.Length; i++)
        //        //{
        //        //    buffer[dataLength + i] = byteDate[i];
        //        //}
        //        logger.Info($"冰箱报警使能【{Convert.ToHexString(buffer)}】");
        //        fridgeSerial.Write(buffer, 0, 8);
        //        await Task.Delay(80);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Info($"冰箱报警使能发生异常：ex:{ex.Message}");
        //    }
        //    FridgeOperate = false;

        //}

        ///// <summary>
        ///// 冰箱报警失能
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridgeAlarmOff(int iIndex)
        //{
        //    try
        //    {
        //        fridgeSerial.DiscardInBuffer();
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] buffer = new byte[] { bAddress, 0x06, 0x10, 0xD5, 0x00, 0x00, 0x9C, 0xF2 };
        //        //byte[] buffer = new byte[] { 0x01, 0x06, 0x10, 0xD5, 0x00, 0x00 };
        //        ////获取数组CRC校验码
        //        //byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //        ////Array.Reverse(byteDate);
        //        //int dataLength = buffer.Length;
        //        //Array.Resize(ref buffer, dataLength + byteDate.Length);
        //        //for (int i = 0; i < byteDate.Length; i++)
        //        //{
        //        //    buffer[dataLength + i] = byteDate[i];
        //        //}
        //        logger.Info($"冰箱报警失能【{Convert.ToHexString(buffer)}】");
        //        fridgeSerial.Write(buffer, 0, 8);
        //        await Task.Delay(80);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Info($"冰箱报警失能发生异常：ex:{ex.Message}");
        //    }
        //    FridgeOperate = false;
        //}
        ///// <summary>
        ///// 冰箱温度设定最小
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridgeMinSetting(float min, int iIndex)
        //{
        //    try
        //    {

        //        int iMix = Convert.ToInt32(min * 10);
        //        fridgeSerial.DiscardInBuffer();
        //        //byte[] bufferMin = new byte[] { 0x01, 0x06, 0x10, 0xC9, 0x00, 0x15, 0x9C, 0xFB };
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] bufferMin = new byte[] { bAddress, 0x06, 0x10, 0xC9, 0x00, (byte)(iMix & 0xff) };
        //        //获取数组CRC校验码
        //        byte[] byteDate = CRC16MODBUS.CrcModBus(bufferMin);
        //        //Array.Reverse(byteDate);
        //        int dataLength = bufferMin.Length;
        //        Array.Resize(ref bufferMin, dataLength + byteDate.Length);
        //        for (int i = 0; i < byteDate.Length; i++)
        //        {
        //            bufferMin[dataLength + i] = byteDate[i];
        //        }
        //        logger.Info($"冰箱温度设定Min:【{Convert.ToHexString(bufferMin)}】");
        //        fridgeSerial.Write(bufferMin, 0, 8);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Info($"获取冰箱温度发生异常：ex:{ex.Message}");
        //    }
        //}
        ///// <summary>
        ///// 冰箱温度设定最大
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridgeMaxSetting(float max, int iIndex)
        //{
        //    try
        //    {
        //        int iMax = Convert.ToInt32(max * 10);
        //        fridgeSerial.DiscardInBuffer();
        //        //byte[] bufferMin = new byte[] { 0x01, 0x06, 0x10, 0xC9, 0x00, 0x15, 0x9C, 0xFB };
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] bufferMax = new byte[] { bAddress, 0x06, 0x10, 0xC8, 0x00, (byte)(iMax & 0xff) };
        //        //获取数组CRC校验码
        //        byte[] byteDate = CRC16MODBUS.CrcModBus(bufferMax);
        //        //Array.Reverse(byteDate);
        //        int dataLength = bufferMax.Length;
        //        Array.Resize(ref bufferMax, dataLength + byteDate.Length);
        //        for (int i = 0; i < byteDate.Length; i++)
        //        {
        //            bufferMax[dataLength + i] = byteDate[i];
        //        }
        //        logger.Info($"冰箱温度设定Max:【{Convert.ToHexString(bufferMax)}】");
        //        fridgeSerial.Write(bufferMax, 0, 8);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Info($"获取冰箱温度发生异常：ex:{ex.Message}");
        //    }
        //}
        ///// <summary>
        ///// 获取冰箱温度
        ///// </summary>
        ///// <returns></returns>
        //public async Task<float> GetFridgeTemperature(int iIndex)
        //{
        //    float temperature = 0.0f;
        //    try
        //    {
        //        fridgeSerial.DiscardInBuffer();
        //        byte bAddress;
        //        if (iIndex == 1)
        //        {
        //            bAddress = 0x01;
        //        }
        //        else
        //        {
        //            bAddress = 0x02;
        //        }
        //        byte[] buffer = new byte[] { bAddress, 0x03, 0x10, 0x02, 0x00, 0x01, 0x21, 0x0A };
        //        //byte[] buffer = new byte[] { 0x01, 0x03, 0x10, 0x02, 0x00, 0x01 };

        //        ////获取数组CRC校验码
        //        //byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //        ////Array.Reverse(byteDate);
        //        //int dataLength = buffer.Length;
        //        //Array.Resize(ref buffer, dataLength + byteDate.Length);
        //        //for (int i = 0; i < byteDate.Length; i++)
        //        //{
        //        //    buffer[dataLength + i] = byteDate[i];
        //        //}

        //        logger.Info($"获取冰箱温度【{Convert.ToHexString(buffer)}】");
        //        fridgeSerial.Write(buffer, 0, 8);

        //        byte[] retByte = await GetBufferByPort(fridgeSerial, 7);

        //        logger.Info($"获取冰箱温度返回【{Convert.ToHexString(retByte)}】");

        //        if (retByte != null && retByte.Length >= 7)
        //        {
        //            var hight = retByte[3];
        //            var low = retByte[4];
        //            int iHight = Convert.ToInt32(hight << 8);
        //            int iLow = Convert.ToInt32(retByte[4]);
        //            temperature = Convert.ToSingle(iHight + iLow) / 10;
        //        }
        //    }
        //    catch (Exception ex)
        //    {

        //        logger.Info($"获取冰箱温度发生异常：ex:{ex.Message}");
        //    }
        //    return temperature;
        //}
        ///// <summary>
        ///// 设置冰箱温度
        ///// </summary>
        ///// <returns></returns>
        //public async Task<float> SetFridgeTemperature(float temperature, int iIndex)
        //{
        //    int tpt = (int)temperature * 10;
        //    byte Temperature = (byte)(tpt & 0xff);
        //    try
        //    {
        //        //if (!FridgeOperate)
        //        {
        //            fridgeSerial.DiscardInBuffer();
        //            byte bAddress;
        //            if (iIndex == 1)
        //            {
        //                bAddress = 0x01;
        //            }
        //            else
        //            {
        //                bAddress = 0x02;
        //            }
        //            //byte[] buffer = new byte[] { 0x01, 0x03, 0x10, 0x02, 0x00, 0x01, 0x21,0x0A };
        //            byte[] buffer = new byte[] { bAddress, 0x06, 0x10, 0x02, 0x00, (byte)Temperature };

        //            //获取数组CRC校验码
        //            byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //            //Array.Reverse(byteDate);
        //            int dataLength = buffer.Length;
        //            Array.Resize(ref buffer, dataLength + byteDate.Length);
        //            for (int i = 0; i < byteDate.Length; i++)
        //            {
        //                buffer[dataLength + i] = byteDate[i];
        //            }
        //            logger.Info($"设置冰箱温度【{Convert.ToHexString(buffer)}】");
        //            fridgeSerial.Write(buffer, 0, 8);

        //            await GetBufferByPort(fridgeSerial, 8);
        //        }
        //    }
        //    catch (Exception ex)
        //    {

        //        logger.Info($"获取冰箱温度发生异常：ex:{ex.Message}");
        //    }
        //    return temperature;
        //}
        ///// <summary>
        ///// 冰箱延迟报警
        ///// </summary>
        ///// <returns></returns>
        //public async Task FridgeDelayWarm(int iIndex)
        //{
        //    try
        //    {
        //        //if (!FridgeOperate)
        //        {
        //            fridgeSerial.DiscardInBuffer();
        //            byte bAddress;
        //            if (iIndex == 1)
        //            {
        //                bAddress = 0x01;
        //            }
        //            else
        //            {
        //                bAddress = 0x02;
        //            }
        //            byte[] buffer = new byte[] { bAddress, 0x06, 0x10, 0xCD, 0x00, 0x01, 0xDD, 0x35 };
        //            //byte[] buffer = new byte[] { 0x01, 0x06, 0x10, 0xCD, 0x00, 0x01 };
        //            ////获取数组CRC校验码
        //            //byte[] byteDate = CRC16MODBUS.CrcModBus(buffer);
        //            ////Array.Reverse(byteDate);
        //            //int dataLength = buffer.Length;
        //            //Array.Resize(ref buffer, dataLength + byteDate.Length);
        //            //for (int i = 0; i < byteDate.Length; i++)
        //            //{
        //            //    buffer[dataLength + i] = byteDate[i];
        //            //}
        //            logger.Info($"冰箱延迟报警【{Convert.ToHexString(buffer)}】");
        //            fridgeSerial.Write(buffer, 0, 8);
        //        }
        //    }
        //    catch (Exception ex)
        //    {

        //        logger.Info($"获取冰箱温度发生异常：ex:{ex.Message}");
        //    }
        //    //FridgeOperate = false;
        //}
        #endregion 

    }
}