aivfo-tl-3.0/ivf_tl_operate_2.0/control/ivf_tl_Com/BufferBottleBin.cs

using DBEntity;
using IvfTl.Control.Entity;
using IvfTl.Control.Entity.DBEntitys;
using IvfTl.Control.Entity.GlobalEntitys;
using IvfTl.Control.Entity.GlobalEnums;
using ivf_tl_SerialHelper.Util;
using ivf_tl_UtilHelper;
using IvfTl.Hardware.Impl;
using System.Diagnostics;

namespace ivf_tl_Com
{
    /// <summary>
    /// 缓冲瓶通信
    /// </summary>
    public class BufferBottleBin
    {
        public event Action<int, DateTime, string, LogEnum> HouseLogEvent;

        public event Action<string, LogEnum> TLLogEvent;

        public event Action<Exception, string, string, LogEnum> ExceptionLogEvent;

        /// <summary>
        /// 舱室运行状态上报 舱室、串口
        /// </summary>
        public event Action<int, int, int, int, int, int> HouseStateEvent;

        int guanbiTime = 0;

        public BufferBottleBin(TLSetting _setting, House _house, int guanbi)
        {
            this.PortName = _house.housePort;
            // M1-03 HAL: 缓冲瓶模块也向 HAL 借用该 COM 口的唯一 ComBin（杜绝同口重复 Open）。
            this.ComBin = (ComBin)HardwareAccessLayer.Instance.GetSerial(_house.houseSn, _house.housePort).RawComBin;
            this.House = _house;
            this.tl_Setting = _setting;
            ComBin.CommandLogEvent += ComBin_CommandLogEvent;
            ComBin.ErrorLogEvent += ComBin_ErrorLogEvent;
            ComBin.ExceptionLogEvent += ComBin_ExceptionLogEvent;
            ComBin.ComStateEvent += ComBin_ComStateEvent;
            guanbiTime = guanbi * 1000;
        }

        private void ComBin_ComStateEvent(int obj)
        {
            HouseStateEvent?.Invoke(House.houseSn, -1, obj, -1, -1, -1);
        }

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

        private void ComBin_ErrorLogEvent(string arg1, LogEnum arg2)
        {
            TLLogEvent?.Invoke(arg1, arg2);
        }

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

        private string PortName = null;

        /// <summary>
        /// 串口通信类
        /// </summary>
        public ComBin ComBin = null;

        public House House = null;

        private TLSetting tl_Setting = null;

        public string RunState { get; set; }

        /// <summary>
        /// 仪器温度1
        /// </summary>
        public decimal Temperature1 = 0m;

        /// <summary>
        /// 仪器温度2
        /// </summary>
        public decimal Temperature2 = 0m;

        /// <summary>
        /// 压力
        /// </summary>
        public decimal BufferBottlePressure = 0m;

        /// <summary>
        /// 当前气压状态
        /// </summary>
        public State ValveState = State.未知;

        public void StartTask()
        {
            Task.Run(() =>
            {
                try
                {
                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]开始初始化", LogEnum.HouseInfo);

                    if (House.openPort == 0)
                    {
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]仓室串口未打开，结束初始化", LogEnum.HouseInfo);
                        return;
                    }
                    var openPort = ComBin.OpenPort();
                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]仓室串口打开结果{openPort}", LogEnum.HouseInfo);
                    if (!openPort)
                    {
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]仓室串口打开失败，结束初始化", LogEnum.HouseInfo);
                        return;
                    }

                    CommandSource commandSource = CommandSource.BufferBottleThread;
                    this.RunState = "握手准备";
                    //缓冲瓶握手
                    var custom = new CustomProtocol();
                    custom.commandSource = commandSource;
                    ComBin.ShakeHandsWait(custom);

                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}] 初始化完成，缓冲瓶开始运行", LogEnum.HouseInfo);
                    MainThread();
                }
                catch (Exception ex)
                {
                    ExceptionLogEvent?.Invoke(ex, $"[{House.houseSn}][{PortName}]初始化异常", null, LogEnum.RunException);
                }
            });
        }

        public void MainThread()
        {
            Task.Factory.StartNew(() =>
            {
                var custom = new CustomProtocol();
                custom.commandSource = CommandSource.BufferBottleThread;
                (decimal, decimal, decimal) a;
                while (true)
                {
                    try
                    {
                        if (StartAirSwap == true)
                        {
                            this.RunState = "舱室换气";
                            IsStartAirSwap = true;
                            a = ComBin.BufferBottleState(custom);
                            BufferBottlePressure = a.Item1;
                            Temperature1 = a.Item2;
                            Temperature2 = a.Item3;
                            HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}] [缓冲瓶气压:{BufferBottlePressure}][仪器温度1:{Temperature1}][仪器温度2:{Temperature2}]【换气逻辑】", LogEnum.HouseInfo);
                            Thread.Sleep(1000);
                            continue;
                        }
                        if (IsStartAirSwap)
                        {
                            IsStartAirSwap = false;
                        }
                        this.RunState = "气压监测";
                        a = ComBin.BufferBottleState(custom);
                        BufferBottlePressure = a.Item1;
                        Temperature1 = a.Item2;
                        Temperature2 = a.Item3;
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}] [缓冲瓶气压:{BufferBottlePressure}][仪器温度1:{Temperature1}][仪器温度2:{Temperature2}]", LogEnum.HouseInfo);

                        if (BufferBottlePressure < tl_Setting.bufferBottlerPressureMin)
                        {
                            ValveState = State.待补气;
                        }
                        else
                        {
                            ValveState = State.正常;
                        }

                        if (BufferBottlePressure < (tl_Setting.bufferBottlerPressureMin + 10))
                        {
                            this.RunState = "缓冲瓶补气";
                            BufferBottleAeration(CommandSource.BufferBottleThread);
                        }
                        this.RunState = "气压监测";
                        Thread.Sleep(1000);
                    }
                    catch (Exception ex)
                    {
                        ExceptionLogEvent?.Invoke(ex, $"[{House.houseSn}][{PortName}]缓冲瓶气压检测", null, LogEnum.RunException);
                    }
                }
            }, TaskCreationOptions.LongRunning);
        }

        /// <summary>
        /// 缓冲瓶补气流程
        /// </summary>
        public void BufferBottleAeration(CommandSource commandSource)
        {
            try
            {
                Stopwatch AerationStopwatch = Stopwatch.StartNew();
                HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}][补气开始时间:{DateTime.Now}]", LogEnum.HouseInfo);
                var custom = new CustomProtocol();
                custom.commandSource = commandSource;
                decimal oldPressure = 0;
                ValveState = State.补气;
                for (int i = 1; i <= tl_Setting.bufferBottlerAerationNum; i++)
                {
                    if (BufferBottlePressure >= (tl_Setting.bufferBottlerPressureMin + 10))
                    {
                        break;
                    }

                    oldPressure = BufferBottlePressure;

                    ComBin.BufferBottleAerationWait(custom);

                    Thread.Sleep(tl_Setting.aerationDelay * 1000);

                    var a = ComBin.BufferBottleState(custom);
                    BufferBottlePressure = a.Item1;
                    Temperature1 = a.Item2;
                    Temperature2 = a.Item3;

                    HouseLogEvent?.Invoke(11, DateTime.Now, $"补气完成[{oldPressure}->{BufferBottlePressure}]", LogEnum.HouseInfo);
                }

                if (BufferBottlePressure < tl_Setting.bufferBottlerPressureMin)
                {
                    ValveState = State.待补气;
                }
                else
                {
                    ValveState = State.正常;
                }

                HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}][补气结束时间:{DateTime.Now}][耗时：{StringHelper.TimeToString(AerationStopwatch.Elapsed)}]", LogEnum.HouseInfo);
                AerationStopwatch.Stop();

            }
            catch (Exception ex)
            {
                ExceptionLogEvent?.Invoke(ex, $"[{House.houseSn}][{PortName}]缓冲瓶补气", null, LogEnum.RunException);
            }
        }


        private object OpenHouseIdsLock = new object();

        public List<int> OpenHouseIds = new List<int>();

        List<HouseBin> HuanQiBinList = new List<HouseBin>();

        public bool IntakeState = false;

        /// <summary>
        /// 开始换气
        /// </summary>
        public bool StartAirSwap { get; set; } = false;

        /// <summary>
        /// 是否准备好开始操作进气阀
        /// </summary>
        private bool IsStartAirSwap { get; set; } = false;


        /// <summary>
        /// 舱室请求打开缓冲瓶进气阀
        /// </summary>
        /// <param name="houseid"></param>
        public void OpenIntakeValve(int houseid)
        {
            lock (OpenHouseIdsLock)
            {
                if (!OpenHouseIds.Contains(houseid))
                {
                    OpenHouseIds.Add(houseid);
                }
                HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]{houseid}舱室请求打开缓冲瓶进气阀，当前状态：{IntakeState},当前换气：{string.Join(";", OpenHouseIds)}]", LogEnum.HouseInfo);

                if (IntakeState)
                {
                    return;
                }
                else
                {
                    StartAirSwap = true;
                    while (true)
                    {
                        if (IsStartAirSwap)
                        {
                            HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]{houseid}号舱室请求打开缓冲瓶进气阀指令已发送", LogEnum.HouseInfo);
                            OpenIntakeValve();
                            return;
                        }
                        else
                        {
                            Thread.Sleep(1000);
                        }
                    }
                }
            }
        }

        private void OpenIntakeValve()
        {
            var custom = new CustomProtocol();
            custom.commandSource = CommandSource.BufferBottleThread;
            if (ComBin.OpenIntakeValveWait(custom, tl_Setting.valueDelay)) IntakeState = true;
        }

        /// <summary>
        /// 舱室请求关闭缓冲瓶进气阀
        /// </summary>
        /// <param name="houseid"></param>
        public void CloseIntakeValve(int houseid)
        {
            lock (OpenHouseIdsLock)
            {
                if (OpenHouseIds.Contains(houseid))
                {
                    OpenHouseIds.Remove(houseid);
                }
                int count = OpenHouseIds.Count;
                HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]{houseid}舱室请求关闭缓冲瓶进气阀，当前状态：{IntakeState},数量：{count}；当前换气：{string.Join(";", OpenHouseIds)}]", LogEnum.HouseInfo);

                if (IntakeState)
                {
                    if (count == 0)
                    {
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{House.houseSn}][{this.PortName}]{houseid}号舱室请求关闭缓冲瓶进气阀指令已发送]", LogEnum.HouseInfo);
                        CloseIntakeValve();
                    }
                }
            }
        }

        private void CloseIntakeValve()
        {
            var custom = new CustomProtocol();
            custom.commandSource = CommandSource.BufferBottleThread;
            if (ComBin.CloseIntakeValveWait(custom, tl_Setting.valueDelay))
            {
                if (guanbiTime > 0) Thread.Sleep(guanbiTime);
                IntakeState = false;
                StartAirSwap = false;
            }
        }

        public void HuanQiStart(HouseBin houseId)
        {
            try
            {
                lock (OpenHouseIdsLock)
                {
                    houseId.StopPai = false;
                    if (!HuanQiBinList.Contains(houseId))
                    {
                        HuanQiBinList.Add(houseId);
                    }
                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{houseId.House.houseSn}号舱室加入队列]，当前队列：{string.Join("、", HuanQiBinList.Select(x => x.House.houseSn))}", LogEnum.HouseInfo);
                    if (HuanQiBinList.Count <= 1)
                    {
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[新舱室排队进入换气队列，缓冲瓶开始换气逻辑]", LogEnum.HouseInfo);
                        HuanQiThread();
                    }
                }
                return;
            }
            catch (Exception ex)
            {
                ExceptionLogEvent?.Invoke(ex, $"[{House.houseSn}][{PortName}]HuanQiStart", null, LogEnum.RunException);
            }
        }

        public void HuanQiEnd(HouseBin houseId)
        {
            try
            {
                lock (OpenHouseIdsLock)
                {
                    if (HuanQiBinList.Contains(houseId))
                    {
                        HuanQiBinList.Remove(houseId);
                    }
                    houseId.StopPai = true;
                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{houseId.House.houseSn}号舱室退出队列]，当前队列：{string.Join("、", HuanQiBinList.Select(x => x.House.houseSn))}", LogEnum.HouseInfo);
                }
                return;
            }
            catch (Exception ex)
            {
                ExceptionLogEvent?.Invoke(ex, $"[{House.houseSn}][{PortName}]HuanQiEnd", null, LogEnum.RunException);
            }
        }

        public void HuanQiThread()
        {
            Task.Run(async () =>
            {
                HouseBin currentHouseBin = null;
                while (true)
                {
                    try
                    {
                        currentHouseBin = null;
                        lock (OpenHouseIdsLock)
                        {
                            HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"换气队列：{string.Join("、", HuanQiBinList.Select(x => x.House.houseSn))}", LogEnum.HouseInfo);
                            if (!HuanQiBinList.Any())
                            {
                                return;
                            }
                            currentHouseBin = HuanQiBinList.First();
                        }
                        if (currentHouseBin == null) continue;
                        if (!HouseIs(currentHouseBin)) continue;
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室开始换气，等待舱室准备完成]", LogEnum.HouseInfo);
                        currentHouseBin.QueueAir = true;
                        while (!currentHouseBin.ReadyAir)
                        {
                            if (!HouseIs(currentHouseBin)) break;
                            Thread.Sleep(500);
                        }
                        if (!HouseIs(currentHouseBin)) continue;
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室准备完成，缓冲瓶进气阀状态：{IntakeState}]", LogEnum.HouseInfo);
                        if (!IntakeState)
                        {
                            StartAirSwap = true;
                            while (true)
                            {
                                if (IsStartAirSwap)
                                {
                                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室]缓冲瓶进气阀打开指令发送", LogEnum.HouseInfo);
                                    OpenIntakeValve();
                                    break;
                                }
                                else
                                {
                                    Thread.Sleep(1000);
                                }
                            }
                        }
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室，缓冲瓶进气阀状态：{IntakeState}，通知舱室缓冲瓶进气阀已打开，并等待舱室冲刷]", LogEnum.HouseInfo);
                        currentHouseBin.OpenBuffer = true;
                        while (currentHouseBin.ReadyAir)
                        {
                            Thread.Sleep(500);
                        }
                        HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室冲刷完成，检查是否关闭进气阀：{IntakeState}]", LogEnum.HouseInfo);
                        lock (OpenHouseIdsLock)
                        {
                            if (HuanQiBinList.Any())
                            {
                                HuanQiBinList.RemoveAt(0);
                                if (!HuanQiBinList.Any() && IntakeState)
                                {
                                    HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室]关闭缓冲瓶进气阀指令发送]", LogEnum.HouseInfo);
                                    CloseIntakeValve();
                                }
                            }
                            currentHouseBin.EndAir = true;
                            HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[{currentHouseBin.House.houseSn}号舱室缓冲瓶相关操作完成，开始下一个舱室，缓冲瓶进气阀状态：{IntakeState}，通知舱室缓冲瓶进气阀操作完成]", LogEnum.HouseInfo);
                            if (!HuanQiBinList.Any())
                            {
                                HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[当前换气队列清空,缓冲瓶退出换气逻辑]", LogEnum.HouseInfo);
                                return;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        ExceptionLogEvent?.Invoke(ex, $"[{House.houseSn}][{PortName}]缓冲瓶换气", null, LogEnum.RunException);
                    }
                }
            });
        }

        /// <summary>
        /// ture继续  false结束
        /// </summary>
        /// <param name="currentHouseBin"></param>
        /// <returns></returns>
        public bool HouseIs(HouseBin currentHouseBin)
        {
            if (currentHouseBin.StopPai)
            {
                HouseLogEvent?.Invoke(House.houseSn, DateTime.Now, $"[检测到{currentHouseBin.House.houseSn}号舱室退出换气，缓冲瓶结束当前舱室换气]", LogEnum.HouseInfo);
                return false;
            }
            return true;
        }
    }
}