PunkHPX8/PunkHPX8_RT/Devices/VpwCell/VpwCellDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Prewet;
using MECF.Framework.Common.CommonData.Vpw;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.Persistent.SRD;
using MECF.Framework.Common.Persistent.Temperature;
using MECF.Framework.Common.Persistent.VpwCell;
using MECF.Framework.Common.Persistent.VpwMain;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.Utilities;
using PunkHPX8_RT.Devices.AXIS;
using PunkHPX8_RT.Devices.Resistivity;
using PunkHPX8_RT.Devices.VpwMain;
using PunkHPX8_RT.Modules;
using PunkHPX8_RT.Modules.Reservoir;
using PunkHPX8_RT.Modules.VpwMain;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Devices.VpwCell
{
    public class VpwCellDevice : BaseDevice, IDevice
    {
        #region 常量 
        private const string COMMON_DATA = "CommonData";
        private const string DIW_FLOW = "DiwFlow";
        private const string VACUUM_PRESSURE = "VacuumPressure";
        private const string FLOW_DRIP = "FlowDrip";
        private const string FLOW_SMALL = "FlowSmall";
        private const string FLOW_LARGE = "FlowLarge";
        private const string VACUUM_VALVE = "VacuumValve";
        private const string VENT_VALVE = "VentValve";
        private const string DRAIN_VALVE = "DrainValve";
        private const string PERSISTENT_VALUE = "PersistentValue";
        private const string LOOPDO_VALUE = "LoopDoValue";
        #endregion

        #region 内部变量
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// 数据
        /// </summary>
        private VpwCellCommonData _commonData=new VpwCellCommonData();
        /// Vpw main数据
        /// </summary>
        private VpwMainCommonData _mainCommonData = new VpwMainCommonData();
        /// <summary>
        /// 持久性数值
        /// </summary>
        private VpwCellPersistentValue _vpwCellPersistentValue;
        /// <summary>
        /// 水平电机
        /// </summary>
        private JetAxisBase _rotationAxis;
        /// <summary>
        /// 水阻计控制器
        /// </summary>
        private ResistivityController _resistivityController;
        /// <summary>
        /// 水阻值
        /// </summary>
        private double _resistivityValue;
        /// <summary>
        /// main device
        /// </summary>
        private VpwMainDevice _vpwMainDevice;
        /// <summary>
        /// cell flow 初始设定值
        /// </summary>
        private double _cellFlowSetValue;
        /// <summary>
        /// total flow 初始设定值
        /// </summary>
        private double _totalFlowSetValue;
        /// <summary>
        /// total流量满足初始设定值自动打开排水阀的时间
        /// </summary>
        private int _dripValveOpenIdlePeriod;
        /// <summary>
        /// 检测到total flow 满足设定条件的时间
        /// </summary>
        private DateTime _totalFlowOkDetectTime;
        /// <summary>
        /// 检测到total flow 是否正常
        /// </summary>
        private bool _totalFlowOK;
        #endregion

        #region 属性
        /// <summary>
        /// 数据
        /// </summary>
        public VpwCellCommonData CommonData { get { return _commonData; } }
        /// <summary>
        /// vpw main数据
        /// </summary>
        public VpwMainCommonData MainCommonData { get { return _mainCommonData; } }
        /// <summary>
        /// 操作模式
        /// </summary>
        public string OperationMode { get { return _vpwCellPersistentValue.OperatingMode; } }
        /// <summary>
        /// 工程模式
        /// </summary>
        public string EngineerMode { get { return _vpwCellPersistentValue.RecipeOperatingMode; } }
        /// <summary>
        /// LoopDO数值
        /// </summary>
        public double LoopDOValue { get { return GetLoopDOValue(); } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public VpwCellDevice(string moduleName) : base(moduleName, moduleName, moduleName, moduleName)
        {
    
        }

        #region 初始化
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeParameter();
            InitializeRoutine();
            SubscribeData();
            SubscribeValueAction();
            InitializeOperation();
            return true;
        }
        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            _vpwCellPersistentValue = VpwCellPersistentManager.Instance.GetPersistentValue(Module);     
            VpwCellItem vpwCellItem=VpwCellItemManager.Instance.GetVpwItem(Module);
            if (vpwCellItem != null)
            {
                _resistivityController = DEVICE.GetDevice<ResistivityController>(vpwCellItem.ResistivityID);
            }
            _vpwMainDevice = DEVICE.GetDevice<VpwMainDevice>($"VPWMain1");
            if(_vpwMainDevice != null)
            {
                _mainCommonData = _vpwMainDevice.CommonData;
            }
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {

        }
        /// <summary>
        /// 订阅
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.{COMMON_DATA}", () => CommonData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{PERSISTENT_VALUE}", () => _vpwCellPersistentValue, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.DiwCellFlow", () => CommonData.DiwFlow, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.VacuumValve", () => CommonData.VacuumValve, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{LOOPDO_VALUE}", ()=> { return GetLoopDOValue(); }, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 获取Loop do数值
        /// </summary>
        /// <returns></returns>
        private double GetLoopDOValue()
        {
            if (_resistivityController != null)
            {
                string value = _resistivityController.ResisitivityValue;
                if (double.TryParse(value, out _resistivityValue))
                {
                    return _resistivityValue;
                }
                else
                {
                    _resistivityValue = 0;
                    return 0;
                }
            }
            else
            {
                return 0;
            }
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeValueAction()
        {
            IoSubscribeUpdateVariable(DIW_FLOW);
            IoSubscribeUpdateVariable(DRAIN_VALVE);
            IoSubscribeUpdateVariable(VACUUM_PRESSURE);
            IoSubscribeUpdateVariable(VACUUM_VALVE);
            IoSubscribeUpdateVariable(VENT_VALVE);
            IoSubscribeUpdateVariable(FLOW_DRIP);
            IoSubscribeUpdateVariable(FLOW_LARGE);
            IoSubscribeUpdateVariable(FLOW_SMALL);
        }
        /// <summary>
        /// 初始化变量
        /// </summary>
        /// <param name="variable"></param>
        private void IoSubscribeUpdateVariable(string variable)
        {
            _variableInitializeDic[variable] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Module, variable, UpdateVariableValue);
        }

        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            PropertyInfo property = _commonData.GetType().GetProperty(variable);
            if (property != null)
            {
                property.SetValue(_commonData, value);
                if (variable == VACUUM_PRESSURE)
                {
                    double torr = UnitUtil.ConvertToTorr((double)value);
                    property.SetValue(_commonData, torr);
                }
            }
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
        }
        /// <summary>
        /// 初始化OP
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.FlowDripOn", (cmd,para)=> { return FlowDripOn(); });
            OP.Subscribe($"{Module}.FlowDripOff", (cmd, para) => { return FlowDripOff(); });
            OP.Subscribe($"{Module}.FlowSmallOn", (cmd, para) => { return FlowSmallOn(); });
            OP.Subscribe($"{Module}.FlowSmallOff", (cmd, para) => { return FlowSmallOff(); });
            OP.Subscribe($"{Module}.FlowLargeOn", (cmd, para) => { return FlowLargeOn(); });
            OP.Subscribe($"{Module}.FlowLargeOff", (cmd, para) => { return FlowLargeOff(); });
            OP.Subscribe($"{Module}.VentValveOn", (cmd, para) => { return VentValveOn(); });
            OP.Subscribe($"{Module}.VentValveOff", (cmd, para) => { return VentValveOff(); });
            OP.Subscribe($"{Module}.DrainValveOn", (cmd, para) => { return DrainValveOn(); });
            OP.Subscribe($"{Module}.DrainValveOff", (cmd, para) => { return DrainValveOff(); });
            OP.Subscribe($"{Module}.VacuumValveOn", (cmd, para) => { return VacuumValveOn(); });
            OP.Subscribe($"{Module}.VacuumValveOff", (cmd, para) => { return VacuumValveOff(); });

            OP.Subscribe($"{Module}.DisabledAction", DisabledOperation);
            OP.Subscribe($"{Module}.ManualAction", ManualOperation);
            OP.Subscribe($"{Module}.AutoAction", AutoOperation);
            OP.Subscribe($"{Module}.EngineeringModeAction", EngineeringModeOperation);
            OP.Subscribe($"{Module}.ProductionModeAction", ProductionModeOperation);
            
            OP.Subscribe($"{Module}.StartRotation", StartRotationAction);
            OP.Subscribe($"{Module}.StopRotation", StopRotationAction);

        }
        #endregion

        #region Action

        private bool StartRotationAction(string cmd, object[] args)
        {
            if (args.Length < 2 && (int)args[0] < 0 && (int)args[1] < 0)
            {
                LOG.WriteLog(eEvent.ERR_VPW, Module, $"Start rotation paramater is wrong");
                return false;
            }
            double targetPostion = (int)args[0]  * 6 * (int)args[1];
            object[] param = new object[] { "",targetPostion };
            int degSpeed = (int)args[0] * 6;
            SetRotationSpeed(degSpeed);
            //return _rotationAxis.JogUpPosition("", param);

            double AfterChangetargetPostion = (int)args[0] * 6 * (int)args[1];
            return RotationProfilePosition(AfterChangetargetPostion);

        }

        private bool StopRotationAction(string cmd, object[] args)
        {
            return _rotationAxis.StopPositionOperation();
        }

        #region Flow
        /// <summary>
        /// Flow Drip on
        /// </summary>
        /// <returns></returns>
        public bool FlowDripOn()
        {
            return WriteVariableValue(FLOW_DRIP, true);
        }
        /// <summary>
        /// Flow Drip Off
        /// </summary>
        /// <returns></returns>
        public bool FlowDripOff()
        {
            return WriteVariableValue(FLOW_DRIP, false);
        }
        /// <summary>
        /// Flow Small On
        /// </summary>
        /// <returns></returns>
        public bool FlowSmallOn()
        {
            return WriteVariableValue(FLOW_SMALL, true);
        }
        /// <summary>
        /// Flow Small Off
        /// </summary>
        /// <returns></returns>
        public bool FlowSmallOff()
        {
            return WriteVariableValue(FLOW_SMALL, false);
        }
        /// <summary>
        /// Flow Large On
        /// </summary>
        /// <returns></returns>
        public bool FlowLargeOn()
        {
            return WriteVariableValue(FLOW_LARGE, true);
        }
        /// <summary>
        /// Flow Large Off
        /// </summary>
        /// <returns></returns>
        public bool FlowLargeOff()
        {
            return WriteVariableValue(FLOW_LARGE, false);
        }
        #endregion

        #region Mode Switch
        /// <summary>
        /// DisabledAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DisabledOperation(string cmd, object[] args)
        {
            string currentOperation = "Disabled";
            VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(Module);
            if (vpwCellEntity != null && _vpwCellPersistentValue != null && _vpwCellPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _vpwCellPersistentValue.OperatingMode;
                if (vpwCellEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_VPWMAIN, Module, $"{Module} is Busy, can't switch to Disabled mode");
                    return false;
                }

                vpwCellEntity.EnterInit();

                _vpwCellPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_VPWMAIN, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }
            VpwCellPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// ManualAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ManualOperation(string cmd, object[] args)
        {
            string currentOperation = "Manual";
            VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(Module);
            if (vpwCellEntity != null && _vpwCellPersistentValue != null && _vpwCellPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _vpwCellPersistentValue.OperatingMode;
                if (vpwCellEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_VPWMAIN, Module, $"{Module} is Busy, can't switch to Manual mode");
                    return false;
                }
                vpwCellEntity.EnterInit();
                _vpwCellPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_VPWMAIN, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }
            VpwCellPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// AutoAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool AutoOperation(string cmd, object[] args)
        {
            string currentOperation = "Auto";
            VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(Module);
            if (vpwCellEntity != null && _vpwCellPersistentValue != null && _vpwCellPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _vpwCellPersistentValue.OperatingMode;
                if (vpwCellEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_VPWMAIN, Module, $"{Module} is Busy, can't switch to Auto mode");
                    return false;
                }
                vpwCellEntity.EnterInit();
                _vpwCellPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_VPWMAIN, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }

            VpwCellPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// EngineeringModeAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool EngineeringModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Engineering";
            if (_vpwCellPersistentValue != null)
            {
                _vpwCellPersistentValue.RecipeOperatingMode = currentRecipeOperation;
            }
            VpwCellPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// ProductionAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ProductionModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Production";
            if (_vpwCellPersistentValue != null)
            {
                _vpwCellPersistentValue.RecipeOperatingMode = currentRecipeOperation;
            }
            VpwCellPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        #endregion

        #region Vent Valve
        /// <summary>
        /// Vent Valve On
        /// </summary>
        /// <returns></returns>
        public bool VentValveOn()
        {
            return WriteVariableValue(VENT_VALVE, true);
        }
        /// <summary>
        /// Vent Valve Off
        /// </summary>
        /// <returns></returns>
        public bool VentValveOff()
        {
            return WriteVariableValue(VENT_VALVE, false);
        }
        #endregion

        #region Drain Valve
        /// <summary>
        /// Drain Valve On
        /// </summary>
        /// <returns></returns>
        public bool DrainValveOn()
        {
            return WriteVariableValue(DRAIN_VALVE, true);
        }
        /// <summary>
        /// Drain Valve Off
        /// </summary>
        /// <returns></returns>
        public bool DrainValveOff()
        {
            return WriteVariableValue(DRAIN_VALVE, false);
        }
        #endregion

        #region Vacuum
        /// <summary>
        /// Vacuum valve on
        /// </summary>
        /// <returns></returns>
        public bool VacuumValveOn()
        {
            return WriteVariableValue(VACUUM_VALVE, true);
        }
        /// <summary>
        /// Vacuum valve off
        /// </summary>
        /// <returns></returns>
        public bool VacuumValveOff()
        {
            return WriteVariableValue(VACUUM_VALVE, false);
        }
        #endregion

        /// <summary>
        /// 写变量
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        private bool WriteVariableValue(string variable, object value)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{variable}");
            return IOModuleManager.Instance.WriteIoValue(ioName, value);
        }

        #endregion

        #region Axis
        /// <summary>
        /// 电机是否上电
        /// </summary>
        /// <returns></returns>
        public bool CheckRotationSwitchOn()
        {
            return _rotationAxis.IsSwitchOn;
        }
        /// <summary>
        /// Home rotation
        /// </summary>
        /// <returns></returns>
        public bool HomeRotation()
        {
            return _rotationAxis.Home();
        }
        /// <summary>
        /// 检验Rotation Home结果
        /// </summary>
        /// <returns></returns>
        public bool CheckHomeEndStatus()
        {
            return CheckRotationEndStatus() && _rotationAxis.IsHomed;
        }
        /// <summary>
        /// 检验Rotation结束状态
        /// </summary>
        /// <returns></returns>
        public bool CheckRotationEndStatus()
        {
            return _rotationAxis.Status == PunkHPX8_Core.RState.End;
        }
        /// <summary>
        /// 检验Rotation失败状态
        /// </summary>
        /// <returns></returns>
        public bool CheckRotationStopStatus()
        {
            return _rotationAxis.Status == PunkHPX8_Core.RState.Failed;
        }
        /// <summary>
        /// 设置速度
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool SetRotationSpeed(int speed)
        {
            _rotationAxis.SetProfileSpeed(speed);
            return true;
        }
        /// <summary>
        /// 改变速度
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool ChangeRotationSpeed(int speed)
        {
            return _rotationAxis.ChangeSpeed(speed);
        }
        /// <summary>
        /// 电机运动
        /// </summary>
        /// <param name="position"></param>
        /// <returns></returns>
        public bool RotationProfilePosition(double position)
        {
            VpwMainDevice vpwCellDevice = DEVICE.GetDevice<VpwMainDevice>(ModuleName.VPWMain1.ToString());
            if (vpwCellDevice != null)
            {
                if (vpwCellDevice.CommonData.ChamberOpened && !vpwCellDevice.CommonData.ChamberClosed)
                {
                    LOG.WriteLog(eEvent.ERR_AXIS, $"{Module}.{Name}", "chamber is not closed, Cannot execute Rotation Profile Position");
                    return false;
                }
            }
            return _rotationAxis.ProfilePositionOperation(position);
        }
        /// <summary>
        /// 停止运动 
        /// </summary>
        /// <returns></returns>
        public bool StopProfilePosition()
        {
            return _rotationAxis.StopPositionOperation();
        }
        /// <summary>
        /// 是否Rotation运动
        /// </summary>
        /// <returns></returns>
        public bool CheckRotationRunning()
        {
            return _rotationAxis.IsRun;
        }
        #endregion
        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        public bool OnTimer()
        {
            if (_rotationAxis != null)
            {
                _rotationAxis.OnTimer();
            }


            //cell flow满足条件过一段时间自动打开排水阀 (非run recipe期间)
            VpwCellEntity vpwcellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(Module);
            if(vpwcellEntity != null && !vpwcellEntity.IsInReceiping)
            {
                CellFlowMonitor();
            } 
            return true;
        }

        //cell flow满足条件过一段时间自动打开排水阀
        private void CellFlowMonitor()
        {
            _cellFlowSetValue = SC.GetValue<double>("VPWMain.Plumbing.CellFlowStartLowLimit");
            _totalFlowSetValue = SC.GetValue<double>("VPWMain.Plumbing.TotalFlowStartLowLimit");
            _dripValveOpenIdlePeriod = SC.GetValue<int>($"{Module}.DripValveOpenIdlePeriod");
            if (MainCommonData.DiwTotalFlow > _totalFlowSetValue)
            {
                if (!_totalFlowOK)
                {
                    _totalFlowOK = true;
                    _totalFlowOkDetectTime = DateTime.Now;
                }
                if ((DateTime.Now - _totalFlowOkDetectTime).TotalSeconds > _dripValveOpenIdlePeriod * 60 && !_commonData.DrainValve)
                {
                    LOG.WriteLog(eEvent.INFO_VPW, Module, $"total flow is large than start limit more than {_dripValveOpenIdlePeriod} min,Drin valve on!");
                    DrainValveOn();
                    _totalFlowOkDetectTime = DateTime.Now;
                    if(_commonData.DiwFlow < _cellFlowSetValue)
                    {
                        LOG.WriteLog(eEvent.WARN_VPW, Module, $"Drin valve open failed!");
                    }
                }
            }
            else
            {
                _totalFlowOK = false;
            }
        }

        /// <summary>
        /// 监控
        /// </summary>
        public void Monitor()
        {
        }

        public void Reset()
        {
        }

        public void Terminate()
        {
        }
    }
}