Virgo_D_SLN/Virgo_DRT/Devices/IODevices/IoHeater.cs

using System;
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.Util;

namespace Virgo_DRT.Devices
{
    public class IoHeater : BaseDevice, IDevice
    {
        public double SetPointLimit
        {
            get
            {
                if (_aoSetPointLimit != null)
                    //return _aoSetPointLimit.Value;
                    return _GetRealFloat(_aoSetPointLimit);

                return 100;
            }
        }

        [Subscription(AITHeaterPropertyName.MonitorTcFeedback)]
        public float MonitorTcFeedback
        {
            get
            {
                if (_aiMonitorTcFeedback == null) return -1;
                //return _aiMonitorTcFeedback.Value;
                return _GetRealFloat(_aiMonitorTcFeedback);
            }
        }

        [Subscription(AITHeaterPropertyName.ControlTcFeedback)]
        public float ControlTcFeedback
        {
            get
            {
                if (Name == "ForelineHeater")
                {
                    if (_aiControlTcFeedback == null) return -1;
                    //return _aiControlTcFeedback.Value;
                    return _GetRealFloat(_aiControlTcFeedback);
                }
                if (_aiControlTcFeedback == null) return -1;
                //return _aiControlTcFeedback.Value;
                float real = _GetRealFloat(_aiControlTcFeedback);
                return real - (float)GetHeaterOffsetSetting(real - _offset);
            }
        }

        [Subscription(AITHeaterPropertyName.ControlTcSetPoint)]
        public float ControlTcSetPoint
        {
            get
            {
                if (_aoSetPoint != null)
                    //return _aoSetPoint.Value;
                    return _GetRealFloat(_aoSetPoint);

                return 0;
            }
            private set
            {
                if (_aoSetPoint != null)
                {
                    //_aoSetPoint.Value = (short)setpoint;
                    _SetRealFloat(_aoSetPoint, value);
                }
            }
        }

        [Subscription(AITHeaterPropertyName.ControlTcSetPointView)]
        public float ControlTcSetPointView
        {
            get
            {
                return _controlTcSetPointView;
            }
        }

        [Subscription(AITHeaterPropertyName.IsMonitorTcBroken)]
        public bool IsMonitorTcBroken
        {
            get
            {
                if (_diMonitorTcBroken != null)
                    return _diMonitorTcBroken.Value;

                return false;
            }
        }

        [Subscription(AITHeaterPropertyName.IsTcDeviation)]
        public bool IsTcDeviation
        {
            get
            {
                if (_diDeviation != null)
                    return _diDeviation.Value;

                return false;
            }
        }

        [Subscription(AITHeaterPropertyName.IsControlTcBroken)]
        public bool IsControlTcBroken
        {
            get
            {
                if (_diControlTcBroken != null)
                    return _diControlTcBroken.Value;

                return false;
            }
        }

        [Subscription(AITHeaterPropertyName.IsPowerOnFeedback)]
        public bool IsPowerOnFeedback
        {
            get
            {
                if (_diPowerOnFeedback != null)
                    return _diPowerOnFeedback.Value;

                if (_doPowerOn != null)
                    return _doPowerOn.Value;

                return false;
            }
        }

        [Subscription(AITHeaterPropertyName.IsPowerOnSetPoint)]
        public bool IsPowerOnSetPoint
        {
            get
            {
                if (_doPowerOn != null)
                    return _doPowerOn.Value;

                return false;
            }
        }

        public string Unit { get; set; }

        private int _stage = 0;
        //private int _stageSet = 0;
        private float _offset = 0f;
        private float _controlTcSetPointView = 0f;
        private readonly DIAccessor   _diPowerOnFeedback;
        private readonly DIAccessor   _diControlTcBroken;
        private readonly DIAccessor   _diMonitorTcBroken;
        private readonly DIAccessor   _diDeviation;
        private readonly DOAccessor   _doPowerOn;
        private readonly AIAccessor   _aiControlTcFeedback;
        private readonly AIAccessor   _aiMonitorTcFeedback;
        private readonly AOAccessor   _aoSetPoint;
        private AOAccessor            _aoSetPointLimit;
        private readonly SCConfigItem _scSetPointLimit;

        private readonly R_TRIG _trigMonitorTcBroken = new R_TRIG();
        private readonly R_TRIG _trigControlTcBroken = new R_TRIG();
        private readonly R_TRIG _trigDeviation = new R_TRIG();

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

            Unit = node.GetAttribute("unit");

            _diPowerOnFeedback   = ParseDiNode("diPowerOnFeedback", node, ioModule);
            _diControlTcBroken   = ParseDiNode("diControlTcBroken", node, ioModule);
            _diMonitorTcBroken   = ParseDiNode("diMonitorTcBroken", node, ioModule);
            _diDeviation         = ParseDiNode("diDeviation", node, ioModule);
            _doPowerOn           = ParseDoNode("doPowerOn", node, ioModule);
            _aiControlTcFeedback = ParseAiNode("aiFeedback", node, ioModule);
            _aiMonitorTcFeedback = ParseAiNode("aiMonitor", node, ioModule);
            _aoSetPoint          = ParseAoNode("aoSetPoint", node, ioModule);
            _aoSetPointLimit     = ParseAoNode("aoSetPointLimit", node, ioModule);
            _scSetPointLimit     = ParseScNodeEx("scSetPointLimit", node, ioModule);
        }

        //public void UpdateConfig(double setPointLimit)
        //{
        //    if (_aoSetPointLimit != null)
        //        _aoSetPointLimit.Value = (short)setPointLimit;
        //}

        public bool Initialize()
        {
            DATA.Subscribe($"{Module}.{Name}.DeviceData", () =>
            {
                AITHeaterData data = new AITHeaterData()
                {
                    Module            = Module,
                    DeviceName        = Name,
                    DeviceSchematicId = DeviceID,
                    DisplayName       = Display,
                    FeedBack          = ControlTcFeedback,
                    MonitorTcFeedBack = MonitorTcFeedback,
                    Scale             = SetPointLimit,
                    SetPoint          = ControlTcSetPointView,
                    IsPowerOn         = IsPowerOnFeedback,
                    IsPowerOnSetPoint = IsPowerOnSetPoint,
                    IsControlTcBroken = IsControlTcBroken,
                    IsMonitorTcBroken = IsMonitorTcBroken,
                    Unit              = Unit,
                    IsTcDeviation     = IsTcDeviation,
                };

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

            DATA.Subscribe($"{Module}.{Name}.Temperature", () => ControlTcFeedback, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            OP.Subscribe($"{Module}.{Name}.{AITHeaterOperation.SetPowerOnOff}", (functionName, param) =>
            {
                bool isEnable = Convert.ToBoolean((string)param[0]);
                return this.TurnOnOff(isEnable);
            });

            OP.Subscribe($"{Module}.{Name}.{AITHeaterOperation.Ramp}", (functionName, param) =>
            {
                float setpoint = (float)Convert.ToDouble((string)param[0]);

                if (!RampTemp(setpoint)) return false;

                return true;
            });

            this.SetBySC(_aoSetPointLimit, _scSetPointLimit);

            return true;
        }

        public bool TurnOnOff(bool on)
        {
            if (!_doPowerOn.SetValue(on, out string reason))
            {
                EV.PostWarningLog(Module, reason);
                return false;
            }

            EV.PostInfoLog(Module, $"Set Heater {Name} Power {(on ? "ON" : "OFF")}");
            return true;
        }

        public bool RampTemp(float setpoint)
        {
            //_stageSet = (setpoint < 100) ? 3 : (setpoint < 200 && setpoint >= 100) ? 5 : (setpoint >= 200) ? 6 : 0;
            _offset = (float)GetHeaterOffsetSetting(setpoint);
            // offset 处理后的设定值
            _controlTcSetPointView = setpoint;
            if (Name == "ForelineHeater")
                ControlTcSetPoint = setpoint;
            else
                ControlTcSetPoint = setpoint + _offset;
            // 是否越界
            if (setpoint > SetPointLimit || setpoint < 0)
            {
                EV.PostAlarmLog(Module, $"{Name} 温度设定 {setpoint} 无效, 正确范围是 (0, {SetPointLimit})");
                return false;
            }
            EV.PostInfoLog(Module, $"设定 {Display} 温度到 {setpoint}");
            return true;
        }

        public void Stop()
        {
            if (_aoSetPoint != null)
            {
                _aoSetPoint.Value = 0;
            }
        }

        public void Terminate()
        {
        }

        public void Monitor()
        {
            _trigControlTcBroken.CLK = IsControlTcBroken;
            if (_trigControlTcBroken.Q)
            {
                EV.PostMessage(Module, EventEnum.DefaultAlarm, $"{Display}, found control TC broken");
            }

            _trigMonitorTcBroken.CLK = IsMonitorTcBroken;
            if (_trigMonitorTcBroken.Q)
            {
                EV.PostMessage(Module, EventEnum.DefaultAlarm, $"{Display}, found monitor TC broken");
            }

            _trigDeviation.CLK = IsTcDeviation;
            if (_trigDeviation.Q)
            {
                EV.PostAlarmLog(Module, $"{Display}, TC Deviation out of range");
            }

            this.SetBySC(_aoSetPointLimit, _scSetPointLimit);
        }

        public void Reset()
        {
            _trigControlTcBroken.RST = true;
            _trigMonitorTcBroken.RST = true;
            _trigDeviation.RST = true;
        }

        private void SetBySC(AOAccessor acc, SCConfigItem scItem)
        {
            if (scItem != null && acc != null)
            {
                //acc.Value = (short)scItem.IntValue;
                _SetRealFloat(acc, scItem.IntValue);
            }
        }

        private float GetHeaterOffsetSetting(double val)
        {
            //return (val >= 25 && val < 50) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset25-50") :
            //    (val >= 50 && val < 75) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset50-75") :
            //    (val >= 75 && val < 100) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset75-100") :
            //    (val >= 100 && val < 125) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset100-125") :
            //    (val >= 125 && val < 150) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset125-150") :
            //    (val >= 150 && val < 175) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset150-175") :
            //    (val >= 175 && val < 200) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset175-200") :
            //    (val >= 200) ? SC.GetValue<Double>($"{Module}.HeaterChamber.HeaterOffset200+") : 0;
            int[] iTempPoint = new int[10];
            float[] fOffsetValue = new float[10];

            try
            {
                for (int i = 1; i < 10; i++)
                {
                    iTempPoint[i] = SC.GetValue<int>($"{Module}.HeaterChamber.TempOffsetPoint_{i}");
                    fOffsetValue[i] = (float)SC.GetValue<double>($"{Module}.HeaterChamber.OffsetValue_{i}");
                    if (val < iTempPoint[i])
                    {
                        return (fOffsetValue[i] - fOffsetValue[i - 1]) / (iTempPoint[i] - iTempPoint[i - 1]) * ((float)val - iTempPoint[i - 1]) + fOffsetValue[i - 1];
                    }
                }
            }
            catch
            { }

            return 0;
        }
    }
}