PunkHPX8/PunkHPX8_RT/Devices/VpwMain/VpwMainDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.OperationCenter;
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.IOCore;
using MECF.Framework.Common.Persistent.Prewet;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Devices.VpwMain
{
    public class VpwMainDevice : BaseDevice, IDevice
    {
        #region 常量 
        private const string COMMON_DATA = "CommonData1";
        private const string PERSISTENT_VALUE = "CommonData";
        private const string CHAMBER_CLOSED = "ChamberClosed";
        private const string CHAMBER_OPENED = "ChamberOpened";
        private const string CHAMBER_CLOSE = "ChamberClose";
        private const string LEAK_DETECTED = "LeakDetected";
        private const string VACUUM_PUMP_PRESSURE = "VacuumPumpPressure";
        private const string VACUUM_PUMP_POWER = "VacuumPumpPower";
        private const string VACUUM_PUMP_ENABLE = "VacuumPumpEnable";
        private const string VACUUM_PUMP_SPEED_ENABLE = "VacuumPumpSpeedEnable";
        private const string VACUUM_PUMP_SPEED = "VacuumPumpSpeed";
        private const string BOOSTER_PUMP_SPEED = "BoosterPumpSpeed";
        private const string BOOSTER_PUMP_ENABLE = "BoosterPumpEnable";
        private const string BOOSTER_PUMP_STATUS = "BoosterPumpStatus";
        private const string DIW_ENABLE = "DiwEnable";
        private const string DIW_PROCESS = "DiwProcess";
        private const string DIW_DEGAS = "DiwDegas";
        private const string DIW_TOTAL_FLOW = "DiwTotalFlow";
        private const string DIW_PRESSURE = "DiwPressure";
        private const string DEGAS_ADJUST = "DegasAdjust";
        private const string DEGAS_PURGE = "DegasPurge";
        private const string DEGAS_PUMP_ENABLE = "DegasPumpEnable";
        private const string DEGAS_PUMP_PRESSURE = "DegasPumpPressure";
        #endregion

        #region 内部变量
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// 数据
        /// </summary>
        private VpwMainCommonData _commonData=new VpwMainCommonData();
        #endregion

        #region 属性
        /// <summary>
        /// 数据
        /// </summary>
        public VpwMainCommonData CommonData { get { return _commonData; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public VpwMainDevice(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()
        {
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {

        }
        /// <summary>
        /// 订阅
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.{PERSISTENT_VALUE}", () => null, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{COMMON_DATA}", () => CommonData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeValueAction()
        {
            IoSubscribeUpdateVariable(CHAMBER_CLOSED);
            IoSubscribeUpdateVariable(CHAMBER_OPENED);
            IoSubscribeUpdateVariable(BOOSTER_PUMP_STATUS);
            IoSubscribeUpdateVariable(BOOSTER_PUMP_SPEED);
            IoSubscribeUpdateVariable(BOOSTER_PUMP_ENABLE);
            IoSubscribeUpdateVariable(DEGAS_PURGE);
            IoSubscribeUpdateVariable(DEGAS_ADJUST);
            IoSubscribeUpdateVariable(DEGAS_PUMP_ENABLE);
            IoSubscribeUpdateVariable(DIW_ENABLE);
            IoSubscribeUpdateVariable(DIW_PROCESS);
            IoSubscribeUpdateVariable(DIW_PRESSURE);
            IoSubscribeUpdateVariable(DIW_DEGAS);
            IoSubscribeUpdateVariable(DIW_TOTAL_FLOW);
            IoSubscribeUpdateVariable(VACUUM_PUMP_ENABLE);
            IoSubscribeUpdateVariable(VACUUM_PUMP_POWER);
            IoSubscribeUpdateVariable(VACUUM_PUMP_PRESSURE);
            IoSubscribeUpdateVariable(VACUUM_PUMP_SPEED);
            IoSubscribeUpdateVariable(VACUUM_PUMP_SPEED_ENABLE);
            IoSubscribeUpdateVariable(LEAK_DETECTED);
        }
        /// <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 (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
        }
        /// <summary>
        /// 初始化OP
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.VacuumPumpPowerOn", (cmd,para)=> { return VacuumPumpPowerOn(); });
            OP.Subscribe($"{Module}.VacuumPumpPowerOff", (cmd, para) => { return VacuumPumpPowerOff(); });
            OP.Subscribe($"{Module}.VacuumPumpEnable", (cmd, para) => { return VacuumPumpEnable(); });
            OP.Subscribe($"{Module}.VacuumPumpDisable", (cmd, para) => { return VacuumPumpDisable(); });
            OP.Subscribe($"{Module}.VacuumPumpSpeedEnable", (cmd, para) => { return VacuumSpeedEnable(); });
            OP.Subscribe($"{Module}.VacuumPumpSpeedDisable", (cmd, para) => { return VacuumSpeedDisable(); });
            OP.Subscribe($"{Module}.VacuumPumpSpeed", (cmd, para) =>{
                short speed = short.Parse(para[0].ToString());
                return WriteVacuumSpeed(speed); });
            OP.Subscribe($"{Module}.DegasPumpEnable", (cmd, para) => { return DegasPumpEnable(); });
            OP.Subscribe($"{Module}.DegasPumpDisable", (cmd, para) => { return DegasPumpDisable(); });
            OP.Subscribe($"{Module}.DegasAdjustOn", (cmd, para) => { return DegasAdjustOn(); });
            OP.Subscribe($"{Module}.DegasAdjustOff", (cmd, para) => { return DegasAdjustOff(); });
            OP.Subscribe($"{Module}.DiwDegasValveOn", (cmd, para) => { return DiwDegasValveOn(); });
            OP.Subscribe($"{Module}.DiwDegasValveOff", (cmd, para) => { return DiwDegasValveOff(); });
            OP.Subscribe($"{Module}.BoosterPumpEnable", (cmd, para) => { return BoosterPumpEnable(); });
            OP.Subscribe($"{Module}.BoosterPumpDisable", (cmd, para) => { return BoosterPumpDisable(); });
            OP.Subscribe($"{Module}.BoosterPumpSpeed", (cmd, para) => {
                short speed = short.Parse(para[0].ToString());
                return BoosterPumpSpeed(speed);
            });

            OP.Subscribe($"{Module}.ChamberUp", (cmd, para) => { return ChamberUp(); });
            OP.Subscribe($"{Module}.ChamberDown", (cmd, para) => { return ChamberDown(); });
            
            OP.Subscribe($"{Module}.BoosterPumpSpeedAuto", (cmd, para) => { return BoosterPumpSpeedAuto(); });
            OP.Subscribe($"{Module}.BoosterPumpSpeedManual", (cmd, para) => { return BoosterPumpSpeedManual(); });
        }
        #endregion

        #region Action

        #region Vacum Pump
        /// <summary>
        /// Pump Power On
        /// </summary>
        /// <returns></returns>
        public bool VacuumPumpPowerOn()
        {
            return WriteVariableValue(VACUUM_PUMP_POWER, true);
        }
        /// <summary>
        /// Pump Power Off
        /// </summary>
        /// <returns></returns>
        public bool VacuumPumpPowerOff()
        {
            return WriteVariableValue(VACUUM_PUMP_POWER, false);
        }
        /// <summary>
        /// Pump Enable
        /// </summary>
        /// <returns></returns>
        public bool VacuumPumpEnable()
        {
            return WriteVariableValue(VACUUM_PUMP_ENABLE, true);
        }
        /// <summary>
        /// Pump Disable
        /// </summary>
        /// <returns></returns>
        public bool VacuumPumpDisable()
        {
            return WriteVariableValue(VACUUM_PUMP_ENABLE, false);
        }
        /// <summary>
        /// Speed Enable
        /// </summary>
        /// <returns></returns>
        public bool VacuumSpeedEnable()
        {
            return WriteVariableValue(VACUUM_PUMP_SPEED_ENABLE, true);
        }
        /// <summary>
        /// Speed disable
        /// </summary>
        /// <returns></returns>
        public bool VacuumSpeedDisable()
        {
            return WriteVariableValue(VACUUM_PUMP_SPEED_ENABLE, false);
        }
        /// <summary>
        /// 写入速度
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool WriteVacuumSpeed(short speed)
        {
            return WriteVariableValue(VACUUM_PUMP_SPEED, speed);
        }
        #endregion

        #region Degas Pump
        /// <summary>
        /// Degas Pump Enable
        /// </summary>
        /// <returns></returns>
        public bool DegasPumpEnable()
        {
            return WriteVariableValue(DEGAS_PUMP_ENABLE, true);
        }
        /// <summary>
        /// Degas Pump disable
        /// </summary>
        /// <returns></returns>
        public bool DegasPumpDisable()
        {
            return WriteVariableValue(DEGAS_PUMP_ENABLE, false);
        }
        /// <summary>
        /// Degas Adjust On
        /// </summary>
        /// <returns></returns>
        private bool DegasAdjustOn()
        {
            return WriteVariableValue(DEGAS_ADJUST, true);
        }
        /// <summary>
        /// Degas Adjust Off
        /// </summary>
        /// <returns></returns>
        private bool DegasAdjustOff()
        {
            return WriteVariableValue(DEGAS_ADJUST, false);
        }
        /// <summary>
        /// DIW Degas Valve On
        /// </summary>
        /// <returns></returns>
        private bool DiwDegasValveOn()
        {
            return WriteVariableValue(DIW_DEGAS, true);
        }
        /// <summary>
        /// DIW Degas Valve Off
        /// </summary>
        /// <returns></returns>
        private bool DiwDegasValveOff()
        {
            return WriteVariableValue(DIW_DEGAS, false);
        }
        #endregion

        #region Booster Pump
        /// <summary>
        /// Booster Pump enable
        /// </summary>
        /// <returns></returns>
        public bool BoosterPumpEnable()
        {
            return WriteVariableValue(BOOSTER_PUMP_ENABLE, true);
        }
        /// <summary>
        /// Booster Pump Disable
        /// </summary>
        /// <returns></returns>
        public bool BoosterPumpDisable()
        {
            return WriteVariableValue(BOOSTER_PUMP_ENABLE, false);
        }
        /// <summary>
        /// 写入Booster泵速
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool BoosterPumpSpeed(short speed)
        {
            return WriteVariableValue(BOOSTER_PUMP_SPEED, speed);
        }
        #endregion

        #region Chamber
        /// <summary>
        /// 上升
        /// </summary>
        /// <returns></returns>
        public bool ChamberUp()
        {
            return WriteVariableValue(CHAMBER_CLOSE, false);
        }
        /// <summary>
        /// 下降
        /// </summary>
        /// <returns></returns>
        public bool ChamberDown()
        {
            return WriteVariableValue(CHAMBER_CLOSE, true);
        }

        public bool BoosterPumpSpeedAuto()
        {
            _commonData.BoosterPumpIsAutoMode = true;
            return true;
        }
        public bool BoosterPumpSpeedManual()
        {
            _commonData.BoosterPumpIsAutoMode = false;
            return true;
        }
        #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

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

        public void Reset()
        {
        }

        public void Terminate()
        {
        }
    }
}