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

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.CommonData.DeviceData;
using System;
using System.Threading.Tasks;
using System.Xml;
using Venus_Core;

namespace Venus_RT.Devices.IODevices
{
    public class IoHighTemperatureHeater : BaseDevice, IDevice
    {
        private readonly DIAccessor _diPowerOnFeedback;
        private readonly DOAccessor _doPowerOn;

        private readonly AIAccessor _aiTemperatureFeedback;
        private readonly AOAccessor _aoTemperatureSetPoint;

        private readonly DIAccessor _diGoPosition1Feedback;
        private readonly DOAccessor _doGoPosition1On;

        private readonly DIAccessor _diGoPosition2Feedback;
        private readonly DOAccessor _doGoPosition2On;

        private readonly DIAccessor _diGoPosition3Feedback;
        private readonly DOAccessor _doGoPosition3On;

        private readonly DIAccessor _diGoPosition4Feedback;
        private readonly DOAccessor _doGoPosition4On;

        private readonly DIAccessor _diGoPosition5Feedback;
        private readonly DOAccessor _doGoPosition5On;

        private readonly DIAccessor _diGoOriginFeedback;
        private readonly DOAccessor _doGoOriginOn;

        private readonly AOAccessor _aoLiftServoPosition1;
        private readonly AOAccessor _aoLiftServoPosition2;
        private readonly AOAccessor _aoLiftServoPosition3;
        private readonly AOAccessor _aoLiftServoPosition4;
        private readonly AOAccessor _aoLiftServoPosition5;
        private readonly AOAccessor _aoOriginSearchHighSpeed;

        private readonly AOAccessor _aoOriginSearchLowSpeed;
        private readonly AOAccessor _aoAbsMoveSpeed;
        private readonly AOAccessor _aoMaximusMoveSpeed;

        private readonly AOAccessor _aoSoftDownLimit;
        private readonly AOAccessor _aoSoftUpLimit;

        private readonly AOAccessor _aoRatio;


        private readonly DIAccessor _diDriverAlarm;
        private readonly DIAccessor _diPosiModuleAlarm;
        private readonly DIAccessor _diORGFailAlarm;

        private readonly DOAccessor _doResetLift;






        private readonly DeviceTimer _originTimer = new DeviceTimer();
        private readonly DeviceTimer _position1Timer = new DeviceTimer();
        private readonly DeviceTimer _position2Timer = new DeviceTimer();
        private readonly DeviceTimer _position3Timer = new DeviceTimer();
        private readonly DeviceTimer _position4Timer = new DeviceTimer();
        private readonly DeviceTimer _position5Timer = new DeviceTimer();


        private int _goPositionTime = 60 * 1000;

        private float HighTemperatureHeaterTemperatureSetPoint;
        private string HighTemperatureHeaterPositipnSetPoint;
        private float HighTemperatureHeaterRatioSetPoint;

        private float _maxTemperatureSetPoint;
        private float _minTemperatureSetPoint;


        private float _maxRatioSetPoint;
        private float _minRatioSetPoint;

        private int _clearAlarmCounter;
        private AITHighTemperatureHeaterData DeviceData
        {
            get
            {
                return new AITHighTemperatureHeaterData
                {
                    Module = Module,
                    DeviceName = Name,
                    DisplayName = Display,
                    HighTemperatureHeaterPositionFeedBack = CurrentPosition.ToString(),
                    HighTemperatureHeaterIsonFeedBack = HighTemperatureHeaterIsOn,
                    HighTemperatureHeaterTemperatureFeedBack = HighTemperatureHighHeaterTemperature,
                    HighTemperatureHeaterRatioFeedBack = HighTemperatureHeaterRatio,

                    HighTemperatureHeaterPositionSetPoint = HighTemperatureHeaterPositipnSetPoint,
                    HighTemperatureHeaterTemperatureSetPoint = HighTemperatureHeaterTemperatureSetPoint,
                    HighTemperatureHeaterRatioSetPoint = HighTemperatureHeaterRatioSetPoint,

                    LiftIsAlarm = IsDriverAlarm || IsPosiModuleAlarm || IsORGFailAlarm
                };
            }
        }
        public bool IsDriverAlarm => _diDriverAlarm.Value;
        public bool IsPosiModuleAlarm => _diPosiModuleAlarm.Value;
        public bool IsORGFailAlarm => _diORGFailAlarm.Value;
        public HighTemperatureHeaterPosition CurrentPosition
        {
            get
            {
                if (_diDriverAlarm.Value || _diPosiModuleAlarm.Value || _diORGFailAlarm.Value)
                {
                    return HighTemperatureHeaterPosition.UnKnow;
                }
                if (_diGoOriginFeedback.Value == true && _diGoPosition1Feedback.Value == false && _diGoPosition2Feedback.Value == false && _diGoPosition3Feedback.Value == false && _diGoPosition4Feedback.Value == false && _diGoPosition5Feedback.Value == false)
                {
                    return HighTemperatureHeaterPosition.Origin;
                }
                if (_diGoOriginFeedback.Value == false && _diGoPosition1Feedback.Value == true && _diGoPosition2Feedback.Value == false && _diGoPosition3Feedback.Value == false && _diGoPosition4Feedback.Value == false && _diGoPosition5Feedback.Value == false)
                {
                    return HighTemperatureHeaterPosition.Position1;
                }
                else if (_diGoOriginFeedback.Value == false && _diGoPosition1Feedback.Value == false && _diGoPosition2Feedback.Value == true && _diGoPosition3Feedback.Value == false && _diGoPosition4Feedback.Value == false && _diGoPosition5Feedback.Value == false)
                {
                    return HighTemperatureHeaterPosition.Position2;
                }
                else if (_diGoOriginFeedback.Value == false && _diGoPosition1Feedback.Value == false && _diGoPosition2Feedback.Value == false && _diGoPosition3Feedback.Value == true && _diGoPosition4Feedback.Value == false && _diGoPosition5Feedback.Value == false)
                {
                    return HighTemperatureHeaterPosition.Position3;
                }
                else if (_diGoOriginFeedback.Value == false && _diGoPosition1Feedback.Value == false && _diGoPosition2Feedback.Value == false && _diGoPosition3Feedback.Value == false && _diGoPosition4Feedback.Value == true && _diGoPosition5Feedback.Value == false)
                {
                    return HighTemperatureHeaterPosition.Position4;
                }
                else if (_diGoOriginFeedback.Value == false && _diGoPosition1Feedback.Value == false && _diGoPosition2Feedback.Value == false && _diGoPosition3Feedback.Value == false && _diGoPosition4Feedback.Value == false && _diGoPosition5Feedback.Value == true)
                {
                    return HighTemperatureHeaterPosition.Position5;
                }
                else
                {
                    return HighTemperatureHeaterPosition.UnKnow;
                }
            }
        }

        public bool HighTemperatureHeaterIsOn
        {
            get
            {
                if (_diPowerOnFeedback.Value == true && _doPowerOn.Value == true)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            set
            {
                SC.SetItemValue($"{Module}.HighTemperatureHeater.IsOn", value);
            }
        }
        public float HighTemperatureHighHeaterTemperature
        {
            get
            {
                if (_aiTemperatureFeedback == null) return -1;
                return _GetRealFloat(_aiTemperatureFeedback);
            }
            set
            {
                if (value <= _maxTemperatureSetPoint && value >= _minTemperatureSetPoint)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $" Set Temperature to {value}");
                    HighTemperatureHeaterTemperatureSetPoint = value;
                    SC.SetItemValue($"{Module}.HighTemperatureHeater.Temperature", value);
                }
                else
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"高温Heater设定温度失败，由于设定温度{value}不在区间[{_minTemperatureSetPoint},{_maxTemperatureSetPoint}]");
                }

            }
        }
        public float HighTemperatureHeaterRatio
        {
            get
            {
                if (_aoRatio == null) return -1;
                return _GetRealFloat(_aoRatio);
            }
            set
            {
                if (value <= _maxRatioSetPoint && value >= _minRatioSetPoint)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $" Set Ratio to {value}");

                    HighTemperatureHeaterRatioSetPoint = value;
                    SC.SetItemValue($"{Module}.HighTemperatureHeater.Ratio", value);
                }
                else
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"高温Heater设定Ratio失败，由于设定温度{value}不在区间[{_minRatioSetPoint},{_maxRatioSetPoint}]");
                }

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

            _diPowerOnFeedback = ParseDiNode("diPowerOnFeedback", node, ioModule);
            _doPowerOn = ParseDoNode("doPowerOn", node, ioModule);

            _aiTemperatureFeedback = ParseAiNode("aiTemperatureFeedback", node, ioModule);
            _aoTemperatureSetPoint = ParseAoNode("aoTemperatureSetPoint", node, ioModule);

            _diGoPosition1Feedback = ParseDiNode("diGoPosition1Feedback", node, ioModule);
            _doGoPosition1On = ParseDoNode("doGoPosition1On", node, ioModule);

            _diGoPosition2Feedback = ParseDiNode("diGoPosition2Feedback", node, ioModule);
            _doGoPosition2On = ParseDoNode("doGoPosition2On", node, ioModule);

            _diGoPosition3Feedback = ParseDiNode("diGoPosition3Feedback", node, ioModule);
            _doGoPosition3On = ParseDoNode("doGoPosition3On", node, ioModule);

            _diGoPosition4Feedback = ParseDiNode("diGoPosition4Feedback", node, ioModule);
            _doGoPosition4On = ParseDoNode("doGoPosition4On", node, ioModule);

            _diGoPosition5Feedback = ParseDiNode("diGoPosition5Feedback", node, ioModule);
            _doGoPosition5On = ParseDoNode("doGoPosition5On", node, ioModule);

            _diGoOriginFeedback = ParseDiNode("diGoOriginFeedback", node, ioModule);
            _doGoOriginOn = ParseDoNode("doGoOriginOn", node, ioModule);

            _aoLiftServoPosition1 = ParseAoNode("aoLiftServoPosition1", node, ioModule);
            _aoLiftServoPosition2 = ParseAoNode("aoLiftServoPosition2", node, ioModule);
            _aoLiftServoPosition3 = ParseAoNode("aoLiftServoPosition3", node, ioModule);
            _aoLiftServoPosition4 = ParseAoNode("aoLiftServoPosition4", node, ioModule);
            _aoLiftServoPosition5 = ParseAoNode("aoLiftServoPosition5", node, ioModule);

            _aoOriginSearchHighSpeed = ParseAoNode("aoOriginSearchHighSpeed", node, ioModule);
            _aoOriginSearchLowSpeed = ParseAoNode("aoOriginSearchLowSpeed", node, ioModule);
            _aoAbsMoveSpeed = ParseAoNode("aoAbsMoveSpeed", node, ioModule);
            _aoMaximusMoveSpeed = ParseAoNode("aoMaximusMoveSpeed", node, ioModule);
            _aoSoftDownLimit = ParseAoNode("aoSoftDownLimit", node, ioModule);
            _aoSoftUpLimit = ParseAoNode("aoSoftUpLimit", node, ioModule);


            _aoRatio = ParseAoNode("aoRatio", node, ioModule);

            _maxTemperatureSetPoint = Convert.ToSingle(SC.GetConfigItem($"{module}.HighTemperatureHeater.Temperature").Max);
            _minTemperatureSetPoint = Convert.ToSingle(SC.GetConfigItem($"{module}.HighTemperatureHeater.Temperature").Min);

            _maxRatioSetPoint = Convert.ToSingle(SC.GetConfigItem($"{module}.HighTemperatureHeater.Ratio").Max);
            _minRatioSetPoint = Convert.ToSingle(SC.GetConfigItem($"{module}.HighTemperatureHeater.Ratio").Min);


            _diDriverAlarm = ParseDiNode("diDriverAlarm", node, ioModule);
            _diPosiModuleAlarm = ParseDiNode("diPosiModuleAlarm", node, ioModule);
            _diORGFailAlarm = ParseDiNode("diORGFailAlarm", node, ioModule);

            _doResetLift = ParseDoNode("doResetLift", node, ioModule);

        }
        public bool GotoPosition(HighTemperatureHeaterPosition highTemperatureHeaterPosition)
        {
            if (!LiftHardwareIsOK())
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo Alarm,can not go to {highTemperatureHeaterPosition}");
                return false;
            }
            if (highTemperatureHeaterPosition != HighTemperatureHeaterPosition.Origin && !LiftSoftwareIsOK())
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo Alarm,can not go to {highTemperatureHeaterPosition}");
                return false;
            }
            LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} start to {highTemperatureHeaterPosition.ToString()}");

            HighTemperatureHeaterPositipnSetPoint = highTemperatureHeaterPosition.ToString();


            switch (highTemperatureHeaterPosition)
            {
                case HighTemperatureHeaterPosition.Origin:
                    _doGoOriginOn.Value = true;
                    _originTimer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position1:
                    _doGoPosition1On.Value = true;
                    _position1Timer.Start(_goPositionTime);

                    break;
                case HighTemperatureHeaterPosition.Position2:
                    _doGoPosition2On.Value = true;
                    _position2Timer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position3:
                    _doGoPosition3On.Value = true;
                    _position3Timer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position4:
                    _doGoPosition4On.Value = true;
                    _position4Timer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position5:
                    _doGoPosition5On.Value = true;
                    _position5Timer.Start(_goPositionTime);
                    break;
            }
            return true;
        }

        public bool Initialize()
        {
            OP.Subscribe($"{Module}.{Name}.GotoPosition", (cmd, args) =>
            {

                var currentPosition = (HighTemperatureHeaterPosition)Enum.Parse(typeof(HighTemperatureHeaterPosition), args[0].ToString());
                GotoPosition(currentPosition);
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.SwitchHighTemperatureHeater", (cmd, args) =>
            {

                HighTemperatureHeaterIsOn = Convert.ToBoolean(args[0].ToString());
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.SetHighTemperatureHeaterTemperature", (cmd, args) =>
            {

                HighTemperatureHighHeaterTemperature = Convert.ToSingle(args[0]);
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.SetHighTemperatureHeaterRatio", (cmd, args) =>
            {
                HighTemperatureHeaterRatio = Convert.ToSingle(args[0]);
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.ResetHighTemperatureHeater", (cmd, args) =>
            {
                ResetSignal();
                return true;
            });
            DATA.Subscribe($"{Module}.{Name}.DeviceData", () => DeviceData, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.{Name}.Temperature", () => DeviceData.HighTemperatureHeaterTemperatureFeedBack);

            DATA.Subscribe($"{Module}.{Name}.Position", () => (int)CurrentPosition - 1);

            DATA.Subscribe($"{Module}.{Name}.IsOn", () => DeviceData.HighTemperatureHeaterIsonFeedBack);
            DATA.Subscribe($"{Module}.{Name}.TemperatureSetPoint", () => DeviceData.HighTemperatureHeaterTemperatureSetPoint);
            DATA.Subscribe($"{Module}.{Name}.Power_Output", () => GetAiValue($"{Module}.AI_CHB_M-HT_Reference_Power_Output"));

            DATA.Subscribe($"{Module}.{Name}.MaxPower", () => GetAiValue($"{Module}.AI_CHB_M-HT_Max_Power"));
            DATA.Subscribe($"{Module}.{Name}.MinPower", () => GetAiValue($"{Module}.AI_CHB_M-HT_Min_Power"));
            DATA.Subscribe($"{Module}.{Name}.Speed", () => GetAiValue($"{Module}.AI_CHB_M-HT_Current_Speed"));
            DATA.Subscribe($"{Module}.{Name}.Posi_Mm", () => GetAiValue($"{Module}.AI_Lift_Servo_Current_Posi_Mm"));
            DATA.Subscribe($"{Module}.{Name}.TM_Temp", () => GetAiValue($"{Module}.AI_CHB_M-HT_Control_TM_Temp"));

            DATA.Subscribe($"{Module}.{Name}.Ratio", () => HighTemperatureHeaterRatio);




            _SetRealFloat(_aoLiftServoPosition1, 20);
            _SetRealFloat(_aoLiftServoPosition2, -30);
            _SetRealFloat(_aoLiftServoPosition3, -40);
            _SetRealFloat(_aoLiftServoPosition4, 20);
            _SetRealFloat(_aoLiftServoPosition5, 50);

            _SetRealFloat(_aoOriginSearchHighSpeed, 10);
            _SetRealFloat(_aoOriginSearchLowSpeed, 5);
            _SetRealFloat(_aoAbsMoveSpeed, 10);
            _SetRealFloat(_aoMaximusMoveSpeed, 20);
            _SetRealFloat(_aoSoftDownLimit, 100);
            _SetRealFloat(_aoSoftUpLimit, 300);

            return true;
        }
        public void Stop()
        {

        }

        public void Terminate()
        {

        }

        public void Monitor()
        {
            if (_originTimer.IsTimeout())
            {
                _originTimer.Stop();
                if (_diGoOriginFeedback.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} {_goPositionTime / 1000} s 内未到原点");
                }
            }
            else if (_originTimer.IsIdle() == false)
            {
                if (_diGoOriginFeedback.Value == true)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} to Origin");
                    _doGoOriginOn.Value = false;
                    _originTimer.Stop();
                }
            }

            if (_position1Timer.IsTimeout())
            {
                _position1Timer.Stop();
                if (_diGoPosition1Feedback.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} {_goPositionTime / 1000} s 内未到Position1");
                }
            }
            else if (_position1Timer.IsIdle() == false)
            {
                if (_diGoPosition1Feedback.Value == true)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} to Position1");
                    _doGoPosition1On.Value = false;
                    _position1Timer.Stop();
                }
            }

            if (_position2Timer.IsTimeout())
            {
                _position2Timer.Stop();
                if (_diGoPosition2Feedback.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} {_goPositionTime / 1000} s 内未到Position2");
                }
            }
            else if (_position2Timer.IsIdle() == false)
            {
                if (_diGoPosition2Feedback.Value == true)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} to Position2");
                    _doGoPosition2On.Value = false;
                    _position2Timer.Stop();
                }
            }

            if (_position3Timer.IsTimeout())
            {
                _position3Timer.Stop();
                if (_diGoPosition3Feedback.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} {_goPositionTime / 1000} s 内未到Position3");
                }
            }
            else if (_position3Timer.IsIdle() == false)
            {
                if (_diGoPosition3Feedback.Value == true)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} to Position3");
                    _doGoPosition3On.Value = false;
                    _position3Timer.Stop();
                }
            }
            if (_position4Timer.IsTimeout())
            {
                _position4Timer.Stop();
                if (_diGoPosition4Feedback.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} {_goPositionTime / 1000} s 内未到Position4");
                }
            }
            else if (_position4Timer.IsIdle() == false)
            {
                if (_diGoPosition4Feedback.Value == true)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} to Position4");
                    _doGoPosition4On.Value = false;
                    _position4Timer.Stop();
                }
            }
            if (_position5Timer.IsTimeout())
            {
                _position5Timer.Stop();
                if (_diGoPosition5Feedback.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} {_goPositionTime / 1000} s 内未到Position5");
                }
            }
            else if (_position5Timer.IsIdle() == false)
            {
                if (_diGoPosition5Feedback.Value == true)
                {
                    LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} to Position5");
                    _doGoPosition5On.Value = false;
                    _position5Timer.Stop();
                }
            }

            var position1Value = (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPosition1") + (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPositionOffset");
            var position2Value = (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPosition2") + (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPositionOffset");
            var position3Value = (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPosition3") + (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPositionOffset");
            var position4Value = (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPosition4") + (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPositionOffset");
            var position5Value = (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPosition5") + (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.LiftServoPositionOffset");


            _SetRealFloat(_aoLiftServoPosition1, position1Value);
            _SetRealFloat(_aoLiftServoPosition2, position2Value);
            _SetRealFloat(_aoLiftServoPosition3, position3Value);
            _SetRealFloat(_aoLiftServoPosition4, position4Value);
            _SetRealFloat(_aoLiftServoPosition5, position5Value);




            _SetRealFloat(_aoOriginSearchHighSpeed, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.OriginSearchHighSpeed"));
            _SetRealFloat(_aoOriginSearchLowSpeed, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.OriginSearchLowSpeed"));
            _SetRealFloat(_aoAbsMoveSpeed, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.AbsMoveSpeed"));
            _SetRealFloat(_aoMaximusMoveSpeed, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.MaximusMoveSpeed"));
            _SetRealFloat(_aoSoftDownLimit, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.SoftDownLimit"));
            _SetRealFloat(_aoSoftUpLimit, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.SoftUpLimit"));


            _SetRealFloat(_aoTemperatureSetPoint, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.Temperature"));
            _SetRealFloat(_aoRatio, (float)SC.GetValue<double>($"{Module}.HighTemperatureHeater.Ratio"));

            _doPowerOn.Value = SC.GetValue<bool>($"{Module}.HighTemperatureHeater.IsOn");



        }
        public bool LiftIsOK()
        {
            if (IsDriverAlarm)
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo Driver Alarm");

                return false;
            }
            if (IsPosiModuleAlarm)
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo Position Module Alarm");
                return false;
            }
            if (IsORGFailAlarm)
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo ORG Fail Alarm");
                return false;
            }
            return true;
        }
        private bool LiftHardwareIsOK()
        {
            if (IsDriverAlarm)
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo Driver Alarm");

                return false;
            }
            if (IsPosiModuleAlarm)
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo Position Module Alarm");
                return false;
            }
            return true;
        }
        private bool LiftSoftwareIsOK()
        {
            if (IsORGFailAlarm)
            {
                LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Lift Servo ORG Fail Alarm");
                return false;
            }
            return true;
        }
        public async void ResetSignal()
        {
            if (_doResetLift.Value == true)
            {
                _doResetLift.Value = false;
                await Task.Delay(200);
            }
            _doResetLift.Value = true;
            await Task.Delay(1000);
            _doResetLift.Value = false;
            _clearAlarmCounter = 0;
            while (IsDriverAlarm || IsPosiModuleAlarm)
            {
                _clearAlarmCounter += 1;
                if (_clearAlarmCounter > 5)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater, Module, $"{Name} Clear Alarm Failed");
                    return;
                }
                else
                { 
                    LOG.Write(eEvent.INFO_PM, Module, $"{Name} Clearing Alarm,Please wait");
                }
                await Task.Delay(1000);
            }
            GotoPosition(HighTemperatureHeaterPosition.Origin);
        }
        public void Reset()
        {

        }
    }
}