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

using System;
using System.Diagnostics;
using System.Xml;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using Aitex.Core.Util;
using MECF.Framework.Common.DBCore;
using Venus_RT.Modules;
using Aitex.Core.RT.Log;
using static Venus_RT.Modules.PMs.PMGasVerificationRoutine;
using Venus_Core;
using MECF.Framework.Common.Equipment;

namespace Venus_RT.Devices.IODevices
{


    public enum MFCWriteMode
    {
        Flow,
        Percent
    }
    //will be upgrade later
    public class MfcBase1 : BaseDevice, IDevice
    {
        public virtual double SetPoint { get; set; }
        public virtual double FeedBack { get; set; }
        public virtual bool IsOutOfTolerance { get; }
        public virtual double Scale { set; get; }
        public virtual string DisplayName { set; get; }

        private float _percent10Calculate;
        private float _percent20Calculate;
        private float _percent30Calculate;
        private float _percent40Calculate;
        private float _percent50Calculate;
        private float _percent60Calculate;
        private float _percent70Calculate;
        private float _percent80Calculate;
        private float _percent90Calculate;
        private float _percent100Calculate;
        private float _verificationCalculate;
        private float _verificationSetpoint;
        private string _verificationResult = "";

        public MfcBase1()
        {
        }

        public virtual bool Initialize()
        {
            DATA.Subscribe($"{Module}.{Name}.VerificationResult", () => _verificationResult);
            DATA.Subscribe($"{Module}.{Name}.FeedBack", () => FeedBack);
            DATA.Subscribe($"{Module}.{Name}.SetPoint", () => SetPoint);


            return true;
        }

        public virtual void Monitor()
        {

        }

        public virtual void Reset()
        {
        }

        public virtual void Terminate()
        {
        }

        public virtual void Ramp(int time)
        {
        }

        public virtual void Ramp(double target, int time)
        {
        }

        public virtual void StopRamp()
        {
        }

        public virtual void SetVerificationResult(float setpoint, float calculateFlow, bool saveResult, double time, double deviation, bool result, int verifyMode)
        {
            if (verifyMode == 0)
            {
                MFCVerificationOnePointData data = new MFCVerificationOnePointData()
                {
                    Module = Module,
                    Name = Name,
                    Setpoint = setpoint,
                    Calculate = calculateFlow,
                };
                MFCVerificationDataRecorder.AddOnePointData(data);
            }
            //ten points
            var delta = Scale / 10;
            _verificationResult += $"{setpoint},{calculateFlow},{time},{deviation},{result};";
            if (delta - 0.1 < setpoint && delta + 0.1 > setpoint)
            {
                _percent10Calculate = calculateFlow;
            }
            else if (2 * delta - 0.1 < setpoint && 2 * delta + 0.1 > setpoint)
            {
                _percent20Calculate = calculateFlow;
            }
            else if (3 * delta - 0.1 < setpoint && 3 * delta + 0.1 > setpoint)
            {
                _percent30Calculate = calculateFlow;
            }
            else if (4 * delta - 0.1 < setpoint && 4 * delta + 0.1 > setpoint)
            {
                _percent40Calculate = calculateFlow;
            }
            else if (5 * delta - 0.1 < setpoint && 5 * delta + 0.1 > setpoint)
            {
                _percent50Calculate = calculateFlow;
            }
            else if (6 * delta - 0.1 < setpoint && 6 * delta + 0.1 > setpoint)
            {
                _percent60Calculate = calculateFlow;
            }
            else if (7 * delta - 0.1 < setpoint && 7 * delta + 0.1 > setpoint)
            {
                _percent70Calculate = calculateFlow;
            }
            else if (8 * delta - 0.1 < setpoint && 8 * delta + 0.1 > setpoint)
            {
                _percent80Calculate = calculateFlow;
            }
            else if (9 * delta - 0.1 < setpoint && 9 * delta + 0.1 > setpoint)
            {
                _percent90Calculate = calculateFlow;
            }
            else if (10 * delta - 0.1 < setpoint && 10 * delta + 0.1 > setpoint)
            {
                _percent100Calculate = calculateFlow;
            }
            else
            {
                _verificationCalculate = calculateFlow;
                _verificationSetpoint = setpoint;
            }

            if (saveResult)
            {
                SaveVerificationData(verifyMode);
            }
        }

        private void SaveVerificationData(int verifyMode)
        {
            var delta = (float)(Scale / 10);
            MFCVerificationData data = new MFCVerificationData()
            {
                Module = Module,
                Name = DisplayName,
                Percent10Setpoint = delta,
                Percent10Calculate = _percent10Calculate,

                Percent20Setpoint = delta * 2,
                Percent20Calculate = _percent20Calculate,

                Percent30Setpoint = delta * 3,
                Percent30Calculate = _percent30Calculate,

                Percent40Setpoint = delta * 4,
                Percent40Calculate = _percent40Calculate,

                Percent50Setpoint = delta * 5,
                Percent50Calculate = _percent50Calculate,

                Percent60Setpoint = delta * 6,
                Percent60Calculate = _percent60Calculate,

                Percent70Setpoint = delta * 7,
                Percent70Calculate = _percent70Calculate,

                Percent80Setpoint = delta * 8,
                Percent80Calculate = _percent80Calculate,

                Percent90Setpoint = delta * 9,
                Percent90Calculate = _percent90Calculate,

                Percent100Setpoint = delta * 10,
                Percent100Calculate = _percent100Calculate,

                Setpoint = _verificationSetpoint,
                Calculate = _verificationCalculate,
            };
            MFCVerificationDataRecorder.Add(data);

            if (verifyMode == 1)
            {
                MFCVerificationTenPointsData tenPointsdata = new MFCVerificationTenPointsData()
                {
                    Module = Module,
                    Name = Name,
                    Percent10Setpoint = delta,
                    Percent10Calculate = _percent10Calculate,

                    Percent20Setpoint = delta * 2,
                    Percent20Calculate = _percent20Calculate,

                    Percent30Setpoint = delta * 3,
                    Percent30Calculate = _percent30Calculate,

                    Percent40Setpoint = delta * 4,
                    Percent40Calculate = _percent40Calculate,

                    Percent50Setpoint = delta * 5,
                    Percent50Calculate = _percent50Calculate,

                    Percent60Setpoint = delta * 6,
                    Percent60Calculate = _percent60Calculate,

                    Percent70Setpoint = delta * 7,
                    Percent70Calculate = _percent70Calculate,

                    Percent80Setpoint = delta * 8,
                    Percent80Calculate = _percent80Calculate,

                    Percent90Setpoint = delta * 9,
                    Percent90Calculate = _percent90Calculate,

                    Percent100Setpoint = delta * 10,
                    Percent100Calculate = _percent100Calculate,

                };
                MFCVerificationDataRecorder.AddTenPointsData(tenPointsdata);

            }
        }

        public void ResetVerificationData()
        {
            _percent10Calculate = 0;
            _percent20Calculate = 0;
            _percent30Calculate = 0;
            _percent40Calculate = 0;
            _percent50Calculate = 0;
            _percent60Calculate = 0;
            _percent70Calculate = 0;
            _percent80Calculate = 0;
            _percent90Calculate = 0;
            _percent100Calculate = 0;
            _verificationCalculate = 0;
            _verificationSetpoint = 0;
            _verificationResult = "";
        }
    }

    public class IoMfc : MfcBase1
    {
        byte[] _buffer_1 = new byte[4];
        byte[] _buffer_2 = new byte[4];
        private MFCWriteMode _writeMode;
        private JetChamber m_JetChamber;
        public string Unit
        {
            get; set;
        }

        //[Subscription(AITMfcDataPropertyName.Scale)]
        public override double Scale
        {
            get
            {
                if (_scN2Scale == null || _scScaleFactor == null)
                    return 0;
                return _scN2Scale.IntValue * _scScaleFactor.DoubleValue;
            }
        }

        //[Subscription(AITMfcDataPropertyName.SetPoint)]
        public override double SetPoint
        {
            get
            {
                if (_aoFlow != null)
                {

                    byte[] high = BitConverter.GetBytes(_aoFlow.Buffer[_aoFlow.Index]);
                    byte[] low = BitConverter.GetBytes(_aoFlow.Buffer[_aoFlow.Index + 1]);
                    _buffer_1[0] = high[0];
                    _buffer_1[1] = high[1];
                    _buffer_1[2] = low[0];
                    _buffer_1[3] = low[1];

                    float flow = BitConverter.ToSingle(_buffer_1, 0);

                    if (_writeMode == MFCWriteMode.Flow)
                    {
                        if (ModuleHelper.IsPm(Module) && (m_JetChamber == JetChamber.VenusSE || m_JetChamber == JetChamber.VenusDE))
                        {
                            return flow;
                        }
                        else
                        {
                            return flow * Scale / RtInstance.ANALOG_TRANS_RANGE;
                        }
                            
                    }
                    else
                    {
                        return Math.Round(flow * Scale / 100, 2);
                    }


                }
                return 0;
            }
            set
            {
                if (_aoFlow != null)
                {
                    byte[] flow;
                    if (_writeMode == MFCWriteMode.Flow)
                    {
                        if (ModuleHelper.IsPm(Module) && (m_JetChamber == JetChamber.VenusSE || m_JetChamber == JetChamber.VenusDE))
                        {
                            flow = BitConverter.GetBytes((float)value );

                        }
                        else 
                        {
                            flow = BitConverter.GetBytes((float)(value * RtInstance.ANALOG_TRANS_RANGE / Scale));
                        }
                        
                    }
                    else
                    {
                        flow = BitConverter.GetBytes((float)(Math.Round(value / Scale * 100, 2)));
                    }

                    _aoFlow.Buffer[_aoFlow.Index] = BitConverter.ToInt16(flow, 0);
                    _aoFlow.Buffer[_aoFlow.Index + 1] = BitConverter.ToInt16(flow, 2);
                }
            }
        }

        //[Subscription(AITMfcDataPropertyName.DefaultSetPoint)]
        public double DefaultSetPoint
        {
            get
            {
                if (_scDefaultSetPoint != null)
                    return _scDefaultSetPoint.IntValue;
                return 0;
            }
        }

        //[Subscription(AITMfcDataPropertyName.FeedBack)]
        public override double FeedBack
        {
            get
            {
                if (_aiFlow != null)
                {
                    byte[] high = BitConverter.GetBytes(_aiFlow.Buffer[_aiFlow.Index]);
                    byte[] low = BitConverter.GetBytes(_aiFlow.Buffer[_aiFlow.Index + 1]);

                    _buffer_2[0] = high[0];
                    _buffer_2[1] = high[1];
                    _buffer_2[2] = low[0];
                    _buffer_2[3] = low[1];
                    float flow = BitConverter.ToSingle(_buffer_2, 0);

                    if (_writeMode == MFCWriteMode.Flow)
                    {
                        if (ModuleHelper.IsPm(Module) &&( m_JetChamber == JetChamber.VenusSE || m_JetChamber == JetChamber.VenusDE))
                            return (_scRegulationFactor != null && _scRegulationFactor.IntValue > 0) ? flow
                                                                                                 : flow * Scale / RtInstance.ANALOG_TRANS_RANGE;
                        else
                            return (_scRegulationFactor != null && _scRegulationFactor.IntValue > 0) ? flow * Scale / RtInstance.ANALOG_TRANS_RANGE / _scRegulationFactor.IntValue
                                                                                                                         : flow * Scale / RtInstance.ANALOG_TRANS_RANGE;
                    }
                    else
                    {
                        return flow * Scale / 100;
                    }
                }
                return 0;
            }
        }

        //[Subscription(AITMfcDataPropertyName.IsOutOfTolerance)]
        public override bool IsOutOfTolerance
        {
            get
            {
                return _toleranceChecker.Result;
            }
        }

        //[Subscription(AITMfcDataPropertyName.IsEnableAlarm)]
        public bool EnableAlarm
        {
            get
            {
                if (_scEnableAlarm != null)
                    return _scEnableAlarm.BoolValue;
                return false;
            }
        }

        //[Subscription(AITMfcDataPropertyName.AlarmRange)]
        public double AlarmRange
        {
            get
            {
                if (_scAlarmRange != null)
                    return _scAlarmRange.IntValue;
                return 0;
            }
        }

        //[Subscription(AITMfcDataPropertyName.AlarmTime)]
        public double AlarmTime
        {
            get
            {
                if (_scAlarmTime != null)
                    return _scAlarmTime.IntValue;
                return 0;
            }
        }

        //[Subscription(AITMfcDataPropertyName.PressureAlarm)]
        public bool PressureAlarm
        {
            get { return _diPressureAlarm != null ? _diPressureAlarm.Value : true; }
        }

        //[Subscription(AITMfcDataPropertyName.MfcAlarm)]
        public bool MfcAlarm
        {
            get
            {
                return _bMfcAlarm;
            }
        }

        //[Subscription(AITMfcDataPropertyName.IsEnable)]
        public bool Enable
        {
            get
            {
                if (_scEnable != null)
                    return _scEnable.BoolValue;
                return false;
            }
        }

        //[Subscription(AITMfcDataPropertyName.IsOffline)]
        public bool IsOffline
        {
            get
            {
                if (_diOffline != null)
                    return _diOffline.Value;

                return false;
            }
        }

        public override string DisplayName
        {
            get
            {
                if (_scGasName != null)
                    return _scGasName.StringValue;
                return Display;
            }
        }

        private DeviceTimer rampTimer = new DeviceTimer();
        private double rampTarget;
        private double rampInitValue;
        private int rampTime;
        private bool _bMfcAlarm = false;
        private bool _bRamping = false;

        private ToleranceChecker _toleranceChecker = new ToleranceChecker();

        private AIAccessor _aiFlow;
        private AOAccessor _aoFlow;
        private AOAccessor _aoRange;
        private DIAccessor _diOffline;
        private DIAccessor _diPressureAlarm;

        private SCConfigItem _scGasName;
        private SCConfigItem _scEnable;
        private SCConfigItem _scN2Scale;
        private SCConfigItem _scScaleFactor;
        private SCConfigItem _scAlarmRange;
        private SCConfigItem _scEnableAlarm;
        private SCConfigItem _scAlarmTime;
        private SCConfigItem _scDefaultSetPoint;
        private SCConfigItem _scRegulationFactor;

        private R_TRIG _trigOffline = new R_TRIG();
        private R_TRIG _trigPressureAlarm = new R_TRIG();

        private string _uniqueName;

        private string GasFlowOutOfTolerance = "GasFlowOutOfTolerance";

        //private JetChamber jetChamber = JetChamber.None;
        public IoMfc(string module, XmlElement node, string ioModule = "")
        {
            Unit = node.GetAttribute("unit");
            base.Module = module;
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");

            _aoRange = ParseAoNode("aoRange", node, ioModule);
            _diOffline = ParseDiNode("diOffline", node, ioModule);
            _aiFlow = ParseAiNode("aiFlow", node, ioModule);
            _aoFlow = ParseAoNode("aoFlow", node, ioModule);
            _diPressureAlarm = ParseDiNode("diPressureAlarm", node, ioModule);

            _scGasName = SC.GetConfigItem($"{Module}.{Name}.GasName");
            _scEnable = SC.GetConfigItem($"{Module}.{Name}.Enable");
            _scN2Scale = SC.GetConfigItem($"{Module}.{Name}.MfcN2Scale");
            _scScaleFactor = SC.GetConfigItem($"{Module}.{Name}.MfcScaleFactor");
            _scAlarmRange = SC.GetConfigItem($"{Module}.{Name}.MfcAlarmRange");
            _scEnableAlarm = SC.GetConfigItem($"{Module}.{Name}.MfcEnableAlarm");
            _scAlarmTime = SC.GetConfigItem($"{Module}.{Name}.MfcAlarmTime");
            _scDefaultSetPoint = SC.GetConfigItem($"{Module}.{Name}.DefaultSetPoint");
            _scRegulationFactor = SC.GetConfigItem($"{module}.{Name}.FlowRegulationFactor");

            _uniqueName = $"{Module}.{Name}";

            //if (module.Contains("PM"))
            //{
            //    jetChamber = (JetChamber)SC.GetValue<int>($"{module}.ChamberType");
            //}
            //_writeMode = (MFCWriteMode)SC.GetValue<int>($"{module}.{Name}.MFCWriteMode");

            if(ModuleHelper.IsPm(module))
                m_JetChamber = (JetChamber)SC.GetValue<int>($"{module}.ChamberType");
            
            if (Name.Contains( "LLA"))
            {
                _writeMode = (MFCWriteMode)SC.GetValue<int>($"LLA.{Name}.MFCWriteMode");
            }
            else if (Name.Contains( "LLB"))
            {
                _writeMode = (MFCWriteMode)SC.GetValue<int>($"LLB.{Name}.MFCWriteMode");

            }
            else
            { 
                _writeMode = (MFCWriteMode)SC.GetValue<int>($"{module}.{Name}.MFCWriteMode");
            }


#if DEBUG
            //Debug.Assert(!string.IsNullOrWhiteSpace(_scGasName.StringValue));
            //Debug.Assert(null != _scN2Scale);
            //Debug.Assert(null != _aoFlow);
            //Debug.Assert(null != _aiFlow);
#endif
        }

        public override bool Initialize()
        {
            EV.Subscribe(new EventItem("Event", GasFlowOutOfTolerance, "Gas Flow Out Of Tolerance", EventLevel.Alarm, EventType.HostNotification));


            DATA.Subscribe($"{Module}.{Name}", () =>
            {
                AITMfcData data = new AITMfcData
                {
                    Type = "MFC",
                    UniqueName = _uniqueName,
                    DeviceName = Name,
                    DeviceSchematicId = DeviceID,
                    DisplayName = DisplayName,
                    FeedBack = FeedBack,
                    SetPoint = SetPoint,
                    Scale = Scale,
                    IsOffline = IsOffline,
                    IsWarning = PressureAlarm
                };

                return data;
            }, SubscriptionAttribute.FLAG.IgnoreSaveDB);


            OP.Subscribe($"{Module}.{Name}.{AITMfcOperation.Ramp}", (name, args) =>
            {
                double target = (double)args[0];
                target = Math.Min(target, Scale);
                target = Math.Max(target, 0);

                Ramp(target, 0);
                LOG.Write(eEvent.EV_DEVICE_INFO, Module, $"Ramp to {target}{Unit}");
                return true;
            });

            DEVICE.Register($"{Module}.{Name}.{AITMfcOperation.Ramp}", (out string reason, int time, object[] param) =>
            {
                double target = Convert.ToDouble((string)param[0]);
                target = Math.Min(target, Scale);
                target = Math.Max(target, 0);

                Ramp(target, time);
                reason = $"{Display} ramp to {target}{Unit}";
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.SetPoint", (cmd, args) =>
            {
                SetPoint = Convert.ToDouble(args[0]);
                return true;
            });
            //@AAA use recipe
            DEVICE.Register($"{Module}.{Name}", (out string reason, int time, object[] param) =>
            {
                double target = Convert.ToDouble((string)param[0]);

                target = Math.Min(target, Scale);
                target = Math.Max(target, 0);

                Ramp(target, time);
                reason = $"{Display} ramp to {target}{Unit}";
                return true;
            });

            return base.Initialize();
        }

        public override void Monitor()
        {
            if (Enable)
            {
                //Ramping();
                CheckTolerance();

                if (_aoRange != null)
                    _aoRange.Value = (short)Scale;

                _trigOffline.CLK = IsOffline;
                if (_trigOffline.Q)
                {
                    LOG.Write(eEvent.ERR_DEVICE_INFO, Module, string.Format("{0} is offline", DisplayName));
                    _bMfcAlarm = true;
                }

                _trigPressureAlarm.CLK = PressureAlarm == false;
                if (_trigPressureAlarm.Q)
                    LOG.Write(eEvent.ERR_DEVICE_INFO, Module, $"{Name}, {DisplayName} Pressure Alarm");
                if (PressureAlarm)
                {
                    _trigPressureAlarm.RST = true;
                }
            }
        }

        public override void Reset()
        {
            _bMfcAlarm = false;
            _toleranceChecker.Reset(AlarmTime);
            _trigPressureAlarm.RST = true;
            _trigOffline.RST = true;
        }

        public override void Terminate()
        {
            _bRamping = false;
            Ramp(DefaultSetPoint, 0);
        }

        public override void Ramp(int time)
        {
            _bRamping = true;
            Ramp(DefaultSetPoint, time);
        }

        public override void Ramp(double target, int time)
        {
            _bRamping = true;
            target = Math.Max(0, target);
            target = Math.Min(Scale, target);
            rampInitValue = SetPoint;    //ramp 初始值取当前设定值，而非实际读取值。零漂问题
            rampTime = time;
            rampTarget = target;
            rampTimer.Start(rampTime);
        }

        public override void StopRamp()
        {
            _bRamping = false;
            Ramp(SetPoint, 0);
        }

        private void Ramping()
        {
            if (_bRamping)
            {
                if (rampTimer.IsTimeout() || rampTime == 0)
                {
                    SetPoint = rampTarget;
                    _bRamping = false;
                }
                else
                {
                    SetPoint = rampInitValue + (rampTarget - rampInitValue) * rampTimer.GetElapseTime() / rampTime;
                }
            }
        }

        private void CheckTolerance()
        {
            if (!EnableAlarm)
                return;

            // 流率检查

            _toleranceChecker.Monitor(FeedBack, SetPoint - Math.Abs(AlarmRange), SetPoint + Math.Abs(AlarmRange), AlarmTime);

            if (_toleranceChecker.Trig)
            {
                LOG.Write(eEvent.ERR_DEVICE_INFO, Module, Display + $"FeedBack {FeedBack} out of Range[{(int)(SetPoint - Math.Abs(AlarmRange))},{(int)(SetPoint + Math.Abs(AlarmRange))}] in {AlarmTime:0} seconds");

                EV.Notify(GasFlowOutOfTolerance);
            }
        }
    }
}