Kepler-Release/Venus/Venus_RT/Devices/IODevices/IoBacksideHe.cs

using System;
using System.Xml;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Venus_RT.Devices.IODevices;
using Aitex.Core.RT.Device.Unit;

namespace Venus_RT.Devices
{
    /// <summary>
    /// 先送Setpoint, 然后再设置控制模式， 切换设置模式后立即生效
    /// </summary>
    public class IoBacksideHe : BaseDevice, IDevice
    {
        private readonly MfcBase1 _mfc;
        private readonly IoValve _DownValve;
        private readonly IoValve _UpValve;
        private readonly IoValve _Up2Valve;
        private readonly IoValve _PumpValve;


        private AOAccessor _aoPressure;
        private AOAccessor _aoCtrlMode;
        private eEvent _lastEvent;
        private string _lastLogInfo;

        public float MinFlowThreshold { get; set;}
        public float MaxFlowThreshold { get; set; }
        public bool OutOfRange { get; private set; }

        public IoBacksideHe(string module, XmlElement node, string ioModule = "")
        {
            base.Module = module;
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");

            _DownValve  = ParseDeviceNode<IoValve>(Module, "downvalve", node);
            _UpValve = ParseDeviceNode<IoValve>(Module, "upvalve", node);
            _Up2Valve = ParseDeviceNode<IoValve>(Module, "up2valve", node);
            _PumpValve = ParseDeviceNode<IoValve>(Module, "pumpvalve", node);


            _mfc = ParseDeviceNode<MfcBase1>(Module, "mfc", node);
            _aoPressure = ParseAoNode("aoPressureSP", node, ioModule);
            _aoCtrlMode = ParseAoNode("aoControlMode", node, ioModule);
        }
        public bool Initialize()
        {
            OutOfRange = false;
            return true;
        }
        public void Monitor()
        {
            if (_mfc != null)
            {
                if (MinFlowThreshold > 0 && _mfc.FeedBack <= MinFlowThreshold)
                {
                    OutOfRange = true;
                    _noRepeatLog(eEvent.WARN_BACKSIDE_HE, $"Backside Helium Flow: {_mfc.FeedBack} exceed min threshold value: {MinFlowThreshold}");
                }
                else if (MaxFlowThreshold > 0 && _mfc.FeedBack >= MaxFlowThreshold)
                {
                    OutOfRange = true;
                    _noRepeatLog(eEvent.WARN_BACKSIDE_HE, $"Backside Helium Flow: {_mfc.FeedBack} exceed max threshold value: {MaxFlowThreshold}");
                }
                else
                {
                    OutOfRange = false;
                }
            }
            

            _DownValve.Monitor();
            _mfc?.Monitor();
        }

        public void Terminate()
        {
        }

        public void Reset()
        {
        }

        public bool HeliumPumpOn(bool On)
        {
            if (On)
            {
                _UpValve?.TurnValve(true, out _);
                _PumpValve?.TurnValve(true, out _);
            }
            else
            {
                _UpValve?.TurnValve(false, out _);
                _PumpValve?.TurnValve(false, out _);
            }

            return true;
        }

        public bool SetBacksideHelium(float mTorr)
        {
            
            _SetRealFloat(_aoPressure, mTorr);
            if (mTorr >= 0.01)
            {
                _DownValve.TurnValve(true, out _);
                //Kepler2300 not define upvalve up2valve
                _UpValve?.TurnValve(true, out _);
                _Up2Valve?.TurnValve(true, out _);



                //this.FlowSP = setpoint;
            }
            else
            {
                _DownValve.TurnValve(false, out _);
                //Kepler2300 not define upvalve up2valve
                _UpValve?.TurnValve(false, out _);
                _Up2Valve?.TurnValve(false, out _);


            }
            SetESCHeControlMode(true);
            return true;
        }

        public bool SetFlowThreshold(float nMin, float nMax)
        {
            MinFlowThreshold = nMin;
            MaxFlowThreshold = nMax;
            return true;
        }
        public void Flow(double setpoint)
        {
            //setpoint = setpoint / 100 * 4000;
            if (setpoint >= 0.01)
            {
                _DownValve.TurnValve(true, out _);
                //this.FlowSP = setpoint;
            }
            else
            {
                _DownValve.TurnValve(false, out _);
            }

           // _mfc.Ramp(setpoint, 1000);
           _mfc.SetPoint=setpoint;

            SetESCHeControlMode(false);
        }

        public void SetESCHeControlMode(bool bPressureMode)
        {
            if(_aoCtrlMode != null)
                _SetRealFloat(_aoCtrlMode, bPressureMode ? 1 : 0);
        }

        private void _noRepeatLog(eEvent evt, string logInfo)
        {
            if(evt != _lastEvent || logInfo != _lastLogInfo)
            {
                LOG.Write(evt, Module, logInfo);
                _lastEvent = evt;
                _lastLogInfo = logInfo;
            }
        }
    }
}