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.DeviceData;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Venus_Core;
using Venus_Unity;

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 DOAccessor _doResetHeater;

        private readonly AIAccessor _aiHeaterPurgeN2Flow;

        private readonly DIAccessor _diMhtrErrorHeatStop;
        private readonly DOAccessor _doMhtrErrorReset;

        private readonly DIAccessor _diWaferTransferPosiSW;

        private readonly AIAccessor _aiHeaterInnerAlarmWord1;
        private readonly AIAccessor _aiHeaterInnerAlarmWord2;
        private readonly AIAccessor _aiHeaterOuterAlarmWord1;
        private readonly AIAccessor _aiHeaterOuterAlarmWord2;




        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 = 30 * 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 Stopwatch _heaterControlStopWatch = new Stopwatch();

        //private R_TRIG innerWord1_TRIG = new R_TRIG();
        //private R_TRIG innerWord2_TRIG = new R_TRIG();
        //private R_TRIG outerWord1_TRIG = new R_TRIG();
        //private R_TRIG outerWord2_TRIG = new R_TRIG();

        private int _innerWord1;
        private int _innerWord2;
        private int _outerWord1;
        private int _outerWord2;

        private bool _isAutoRatio;
        private List<RatioValue> _ratioValues = new List<RatioValue>();

        private Stopwatch _ratioStopwatch=new Stopwatch();
        private int RangeIndex=-1;
        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,
                    HighTemperatureHeaterN2Flow = HighTemperatureHeaterN2Flow,
                    LiftIsAlarm = IsDriverAlarm || IsPosiModuleAlarm || IsORGFailAlarm,
                    HeaterIsAlarm = _diMhtrErrorHeatStop.Value,
                    IsAutoRatio = _isAutoRatio
                };
            }
        }
        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_SetTemperature_OverRange, Module, value.ToString(), _minTemperatureSetPoint.ToString(), _maxTemperatureSetPoint.ToString());
                }

            }
        }
        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_SetRatio_OverRange, Module, value.ToString(), _minRatioSetPoint.ToString(), _maxRatioSetPoint.ToString());
                }

            }
        }
        public float HighTemperatureHeaterN2Flow
        {
            get
            {
                if (_aiHeaterPurgeN2Flow == null) return -1;
                return _GetRealFloat(_aiHeaterPurgeN2Flow);
            }
        }
        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);

            _aiHeaterInnerAlarmWord1 = ParseAiNode("aiHeaterInnerAlarmWord1", node, ioModule);
            _aiHeaterInnerAlarmWord2 = ParseAiNode("aiHeaterInnerAlarmWord2", node, ioModule);
            _aiHeaterOuterAlarmWord1 = ParseAiNode("aiHeaterOuterAlarmWord1", node, ioModule);
            _aiHeaterOuterAlarmWord2 = ParseAiNode("aiHeaterOuterAlarmWord2", 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);
            _doResetHeater = ParseDoNode("doResetHeater", node, ioModule);


            _aiHeaterPurgeN2Flow = ParseAiNode("aiHeaterPurgeN2Flow", node, ioModule);

            _diMhtrErrorHeatStop = ParseDiNode("diMhtrErrorHeatStop", node, ioModule);
            _doMhtrErrorReset = ParseDoNode("doMhtrErrorReset", node, ioModule);
            _diWaferTransferPosiSW = ParseDiNode("diWaferTransferPosiSW", node, ioModule);

            UpdateAutoRatio();
            _ratioStopwatch.Start();
        }
        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:
                    _doGoPosition1On.Value = false;
                    _doGoPosition2On.Value = false;
                    _doGoPosition3On.Value = false;
                    _doGoPosition4On.Value = false;
                    _doGoPosition5On.Value = false;
                    _doGoOriginOn.Value = true;
                    _originTimer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position1:

                    _doGoPosition2On.Value = false;
                    _doGoPosition3On.Value = false;
                    _doGoPosition4On.Value = false;
                    _doGoPosition5On.Value = false;
                    _doGoOriginOn.Value = false;
                    _doGoPosition1On.Value = true;
                    _position1Timer.Start(_goPositionTime);

                    break;
                case HighTemperatureHeaterPosition.Position2:
                    _doGoPosition1On.Value = false;
                    _doGoPosition3On.Value = false;
                    _doGoPosition4On.Value = false;
                    _doGoPosition5On.Value = false;
                    _doGoOriginOn.Value = false;
                    _doGoPosition2On.Value = true;
                    _position2Timer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position3:
                    _doGoPosition1On.Value = false;
                    _doGoPosition2On.Value = false;
                    _doGoPosition4On.Value = false;
                    _doGoPosition5On.Value = false;
                    _doGoOriginOn.Value = false;
                    _doGoPosition3On.Value = true;
                    _position3Timer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position4:
                    _doGoPosition1On.Value = false;
                    _doGoPosition2On.Value = false;
                    _doGoPosition3On.Value = false;
                    _doGoPosition5On.Value = false;
                    _doGoOriginOn.Value = false;
                    _doGoPosition4On.Value = true;
                    _position4Timer.Start(_goPositionTime);
                    break;
                case HighTemperatureHeaterPosition.Position5:
                    _doGoPosition1On.Value = false;
                    _doGoPosition2On.Value = false;
                    _doGoPosition3On.Value = false;
                    _doGoPosition4On.Value = false;
                    _doGoOriginOn.Value = false;
                    _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}.ResetHighTemperatureHeaterLift", (cmd, args) =>
            {
                ResetLift();
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.ResetHighTemperatureHeater", (cmd, args) =>
            {
                ResetHeater();
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.SetAutoRatio", (cmd, args) =>
            {
                UpdateAutoRatio();
                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}.InnerCurrent", () => GetAiValue($"{Module}.AI_CHB_M-HT_Inner_Current_FB"));
            DATA.Subscribe($"{Module}.{Name}.InnerVoltage", () => GetAiValue($"{Module}.AI_CHB_M-HT_Inner_Voltage_FB"));
            DATA.Subscribe($"{Module}.{Name}.InnerPower", () => GetAiValue($"{Module}.AI_CHB_M-HT_Inner_Power_FB"));
            DATA.Subscribe($"{Module}.{Name}.InnerResistance", () => GetAiValue($"{Module}.AI_CHB_M-HT_Inner_Resistance_FB"));

            DATA.Subscribe($"{Module}.{Name}.OuterCurrent", () => GetAiValue($"{Module}.AI_CHB_M-HT_Outer_Current_FB"));
            DATA.Subscribe($"{Module}.{Name}.OuterVoltage", () => GetAiValue($"{Module}.AI_CHB_M-HT_Outer_Voltage_FB"));
            DATA.Subscribe($"{Module}.{Name}.OuterPower", () => GetAiValue($"{Module}.AI_CHB_M-HT_Outer_Power_FB"));
            DATA.Subscribe($"{Module}.{Name}.OuterResistance", () => GetAiValue($"{Module}.AI_CHB_M-HT_Outer_Resistance_FB"));

            DATA.Subscribe($"{Module}.{Name}.PurgeN2Flow", () => GetAiValue($"{Module}.AI_Heater_Purge_N2_Flow"));

            DATA.Subscribe($"{Module}.{Name}.ShaftTCTemp", () => GetAiValue($"{Module}.AI_HTR_Shaft_TC_Temp"));
            DATA.Subscribe($"{Module}.{Name}.SourceTCTemp", () => GetAiValue($"{Module}.AI_Source_TC_Temp"));

            DATA.Subscribe($"{Module}.{Name}.HeaterDriverAlarm", () => _diMhtrErrorHeatStop.Value);

            //DATA.Subscribe($"{Module}.{Name}.InnerAlarmWord1", () => GetAiValue($"{Module}.AI_CHB_M-HT_Inner_Alarm_Word1"));
            //DATA.Subscribe($"{Module}.{Name}.InnerAlarmWord2", () => GetAiValue($"{Module}.AI_CHB_M-HT_Inner_Alarm_Word2"));
            //DATA.Subscribe($"{Module}.{Name}.OuterAlarmWord1", () => GetAiValue($"{Module}.AI_CHB_M-HT_Outer_Alarm_Word1"));
            //DATA.Subscribe($"{Module}.{Name}.OuterAlarmWord2", () => GetAiValue($"{Module}.AI_CHB_M-HT_Outer_Alarm_Word2"));


            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);

            _heaterControlStopWatch.Start();

            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_GoOriginTimeOut, 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_GoPosition1TimeOut, Module, $"{Name} {_goPositionTime / 1000} s 内未到Position1");
                }
                if (_diWaferTransferPosiSW.Value == false)
                {
                    LOG.Write(eEvent.ERR_HighTemperatureHeater_TransferPosition, Module, $"{Name} {_goPositionTime / 1000} s 内未到传片位");
                }

            }
            else if (_position1Timer.IsIdle() == false)
            {
                if (_diGoPosition1Feedback.Value == true && _diWaferTransferPosiSW.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_GoPosition2TimeOut, 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_GoPosition3TimeOut, 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_GoPosition4TimeOut, 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_GoPosition5TimeOut, 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");
            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);

            _isAutoRatio = SC.GetValue<bool>($"{Module}.HighTemperatureHeater.IsEnableAutoRatio");


            _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");

            if (_heaterControlStopWatch.ElapsedMilliseconds > 10 * 1000)
            {
                _heaterControlStopWatch.Restart();

                var innerWord1 = (int)_GetRealFloat(_aiHeaterInnerAlarmWord1);
                if (innerWord1 > 0 && innerWord1 != _innerWord1)
                {
                    var innerWord1Value = ConvertToBitArray(innerWord1);
                    AlarmWord1(innerWord1Value, "Inner Word1");
                }
                _innerWord1 = innerWord1;

                var innerWord2 = (int)_GetRealFloat(_aiHeaterInnerAlarmWord2);
                //innerWord2_TRIG.CLK = innerWord2 > 0;
                if (innerWord2 > 0 && innerWord2 != _innerWord2)
                {
                    var innerWord2Value = ConvertToBitArray(innerWord2);
                    AlarmWord2(innerWord2Value, "Inner Word2");
                }
                _innerWord2 = innerWord2;


                var outerWord1 = (int)_GetRealFloat(_aiHeaterOuterAlarmWord1);
                //outerWord1_TRIG.CLK = outerWord1 > 0;
                if (outerWord1 > 0 && outerWord1 != _outerWord1)
                {
                    var outerWord1Value = ConvertToBitArray(outerWord1);
                    AlarmWord1(outerWord1Value, "Outer Word1");
                }
                _outerWord1 = outerWord1;

                var outerWord2 = (int)_GetRealFloat(_aiHeaterOuterAlarmWord2);
                //outerWord2_TRIG.CLK = outerWord2> 0;
                if (outerWord2 > 0 && outerWord2 != _outerWord2)
                {
                    var outerWord2Value = ConvertToBitArray(outerWord2);
                    AlarmWord2(outerWord2Value, "Outer Word2");
                }
                _outerWord2 = outerWord2;

            }

            if (_ratioStopwatch.ElapsedMilliseconds > 2000)
            {
                foreach (var item in _ratioValues)
                {
                    int index= _ratioValues.IndexOf(item);
                    if (_isAutoRatio == false)
                    {
                        RangeIndex = -1;
                        break;
                    }
                    if (_isAutoRatio && HighTemperatureHighHeaterTemperature >= item.MinValue && HighTemperatureHighHeaterTemperature <= item.MaxValue && RangeIndex != index)
                    {
                        HighTemperatureHeaterRatio = item.Ratio;
                        RangeIndex = index;
                        break;
                    }
                }

            }
        }
        public bool[] ConvertToBitArray(int number)
        {
            var bitArray = new bool[sizeof(int) * 8]; // 创建一个bool数组，大小为int类型的位数
            for (int i = 0; i < bitArray.Length; i++)
            {
                bitArray[i] = (number & (1 << i)) != 0; // 将number的第i位与1做位与运算，如果结果不为0，则该位为true
            }
            return bitArray;
        }



        private void AlarmWord1(bool[] word1, string name)
        {
            if (word1[0] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Missing Mains");
            }
            if (word1[1] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Thyristor short circuit");
            }
            if (word1[3] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Network Dips");
            }
            if (word1[4] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Frequency Fault");
            }
            if (word1[5] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} T.L.F");
            }
            if (word1[6] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Chop Off");
            }
            if (word1[7] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} P.L.F");
            }
            if (word1[8] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} P.L.U");
            }
            if (word1[9] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Over Voltage");
            }
            if (word1[10] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Under Voltage");
            }
            if (word1[12] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Over Current");
            }
            if (word1[14] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Analn Over Current");
            }
            if (word1[15] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} External Input");
            }
        }
        private void AlarmWord2(bool[] word2, string name)
        {
            if (word2[0] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Closed Loop break");
            }
            if (word2[1] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Transfer Active");
            }
            if (word2[2] == true)
            {
                LOG.Write(eEvent.WARN_HighTemperatureHeater, Module, $"{name} Limit Active");
            }
        }
        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 ResetLift()
        {
            if (_doResetHeater.Value == true)
            {
                _doResetHeater.Value = false;
                await Task.Delay(200);
            }
            _doResetHeater.Value = true;
            await Task.Delay(1000);

            _doResetHeater.Value = true;

            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 async void ResetHeater()
        {
            if (_diMhtrErrorHeatStop.Value)
            {
                if (_doMhtrErrorReset.Value == true)
                {
                    _doMhtrErrorReset.Value = false;
                    await Task.Delay(200);
                }
                _doMhtrErrorReset.Value = true;
                LOG.Write(eEvent.INFO_HighTemperatureHeater, Module, $"{Name} Reset Heater");
            }
        }

        private void UpdateAutoRatio()
        {
            try
            {
                RangeIndex = -1;
                var ratioValueString = SC.GetStringValue($"{Module}.HighTemperatureHeater.AutoRatioValue");
                _ratioValues = SerializeHelper.Instance.JsonStringToObject<List<RatioValue>>(ratioValueString);
            }
            catch 
            {

            }  
        }


        //private string FloatToHex(float value)
        //{
        //    byte[] bytes = BitConverter.GetBytes(value);
        //    StringBuilder stringBuffer = new StringBuilder();

        //    for (int i = 0; i < bytes.Length; i++)
        //    {
        //        string hex = Convert.ToString(bytes[i], 2);
        //        stringBuffer.Insert(0, hex);

        //        for (int j = hex.Length; j < 8; j++)
        //        {
        //            stringBuffer.Insert(0, "0");
        //        }
        //    }
        //    return stringBuffer.ToString();
        //}
        public void Reset()
        {

        }
    }
}