PunkHPX8/PunkHPX8_RT/Devices/Dose/CrossDoseHelper.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.Dose;
using PunkHPX8_RT.Modules;
using PunkHPX8_RT.Modules.Reservoir;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.ProcessCell;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.TwinCat;
using System;
using System.Reflection;
using System.Windows;
using static PunkHPX8_RT.Devices.Reservoir.DosingSystemHelper;

namespace PunkHPX8_RT.Devices.Reservoir
{
    public class CrossDoseHelper
    {
        #region 常量        
        public enum CrossDoseOperation
        {
            None,
            ManualDosing,
            AutoDosing,
        }
        /// <summary>
        /// 补液体积（固定10mL）
        /// </summary>
        private const double DOSING_VOLUME = 10;
        #endregion
        #region 内部变量
        /// <summary>
        /// ModuleName
        /// </summary>
        private string _moduleName;
        /// <summary>
        /// CrossDoseResetRoutine
        /// </summary>
        private CrossDoseResetRoutine _crossDoseResetRoutine;
        /// <summary>
        /// ReservoirsPersistentValue
        /// </summary>
        private ReservoirsPersistentValue _persistentValue;
        /// <summary>
        /// CrossDoseVolume
        /// </summary>
        private double _crossDoseVolume;
        /// <summary>
        /// 当前CrossDose模式
        /// </summary>
        private CrossDoseOperation _currentCrossDoseOperation;
        /// <summary>
        /// Reservoir Usage
        /// </summary>
        private ReservoirUsage _reservoirUsage;
        private bool _flag;

        #endregion

        #region 属性
        /// <summary>
        /// 当前Dose模式
        /// </summary>
        public CrossDoseOperation CurrentDoseOperation{ get {return _currentCrossDoseOperation; } }
        /// <summary>
        /// ResetRoutine当前的RState
        /// </summary>
        public RState ResetState { get { return _crossDoseResetRoutine.CurrentState; } }
        #endregion

        public CrossDoseHelper(string moduleName) 
        {
            _moduleName = moduleName;   
            _crossDoseResetRoutine = new CrossDoseResetRoutine(_moduleName);
            _persistentValue = ReservoirsPersistentManager.Instance.GetReservoirsPersistentValue(_moduleName);
            _currentCrossDoseOperation = CrossDoseOperation.None;
        }

        #region Operation
        /// <summary>
        /// 开始Dosing
        /// </summary>
        /// <returns></returns>
        public bool StartDosing(double crossDoseVolume)
        {
            return false;
        }
        /// <summary>
        /// 停止Dosing
        /// </summary>
        /// <returns></returns>
        public bool HaltDosing()
        {
            EnterError();
            return true;
        }
        /// <summary>
        /// CrossDosing监控
        /// </summary>
        public void CrossDoseStatusMonitor()
        {
            
        }
        /// <summary>
        /// 自动CrossDose监控
        /// </summary>
        public void AutoCrossDoseMonitor(bool isInitialized)
        {
            if (!isInitialized)
            {               
                if (!_flag)
                {
                    LOG.WriteLog(eEvent.WARN_RESERVOIR, _moduleName, "Please initialize Cross Dose");
                    _flag = true;
                }                
                return;
            }
            _flag = false;
        }
        /// <summary>
        /// 自动补液触发时机判断
        /// </summary>
        /// <returns></returns>
        private bool AutoDosingMonitor()
        {
            return true;
        }
        /// <summary>
        /// 设置手动Dose模式
        /// </summary>
        public void SetManualDoseOperation()
        {
            _currentCrossDoseOperation = CrossDoseOperation.ManualDosing;
        }
        /// <summary>
        /// 设置自动Dose模式
        /// </summary>
        public void SetAutoDoseOperation()
        {
            _currentCrossDoseOperation = CrossDoseOperation.AutoDosing;           
        }
        /// <summary>
        /// 重置Dose模式
        /// </summary>
        public void ResetDoseOperation()
        {
            _currentCrossDoseOperation = CrossDoseOperation.None;
        }
        /// <summary>
        /// EnterError
        /// </summary>
        private bool EnterError()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{_moduleName}.TransferPumpExecute");
            bool result = IOModuleManager.Instance.WriteIoValue(ioName, false);
            if (!result)
            {
                return false;
            }
            ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{_moduleName}.TransferPumpEnable");
            result = IOModuleManager.Instance.WriteIoValue(ioName, false);
            if (!result)
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 记录AutoCrossDose开始时的时间和电量
        /// </summary>
        private void RecordStartData()
        {
            _reservoirUsage = ReservoirUsageManager.Instance.GetReservoirUsage(_moduleName);
            _persistentValue.AutoCrossDoseStartTime = DateTime.Now;
            if (_reservoirUsage != null) _persistentValue.AutoCrossDoseStartAmpHour = _reservoirUsage.TotalUsage;
            ReservoirsPersistentManager.Instance.UpdatePersistentValue(_moduleName);
        }
        /// <summary>
        /// 设置PumpFactor
        /// </summary>
        public void SetPumpfactor(double targetPumpFactor)
        {
            _persistentValue.CrossDosePumpFactor = targetPumpFactor;
            ReservoirsPersistentManager.Instance.UpdatePersistentValue(_moduleName);
        }
        /// <summary>
        /// Reset Start
        /// </summary>
        public bool ResetCrossDose()
        {                           
            return _crossDoseResetRoutine.Start() == RState.Running;
        }
        /// <summary>
        /// Reset Start Monitor
        /// </summary>
        /// <returns></returns>
        public bool ResetCrossDoseMonitor()
        {
            RState result = _crossDoseResetRoutine.Monitor();
            if (result == RState.Failed || result == RState.Timeout)
            {
                LOG.WriteLog(eEvent.WARN_RESERVOIR, _moduleName, "Reset Cross Dose failed");
                return false;
            }
            return result == RState.End;
        }

        #endregion
    }
}