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








        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 AITHighTemperatureHeaterData DeviceData
        {
            get
            {
                return new AITHighTemperatureHeaterData
                {
                    Module = Module,
                    DeviceName = Name,
                    DisplayName = Display,
                    HighTemperatureHeaterPosition = CurrentPosition.ToString(),
                    HighTemperatureHeaterIson = HighTemperatureHeaterIsOn,
                    HighTemperatureHeaterTemperature = HighTemperatureHighHeaterTemperature,
                    HighTemperatureHeaterRate = HighTemperatureHeaterRate

                };
            }
        }

        public HighTemperatureHeaterPosition CurrentPosition
        {
            get
            {
                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
            {
                _doPowerOn.Value = value;
            }
        }
        public float HighTemperatureHighHeaterTemperature
        {
            get
            {
                if (_aiTemperatureFeedback == null) return -1;
                return _GetRealFloat(_aiTemperatureFeedback);
            }
            set
            {
                _SetRealFloat(_aoTemperatureSetPoint, value);
            }
        }

        public float HighTemperatureHeaterRate
        {
            get
            {
                if (_aoRate == null) return -1;
                return _GetRealFloat(_aoRate);
            }
            set
            {
                _SetRealFloat(_aoRate, value);
            }
        }
        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);


            _aoRate= ParseAoNode("aoRate", node, ioModule);





        }
        public bool GotoPosition(HighTemperatureHeaterPosition highTemperatureHeaterPosition)
        {
            if (CurrentPosition == highTemperatureHeaterPosition)
            {
                return true;
            }
            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}.SetHighTemperatureHeaterRate", (cmd, args) =>
            {

                HighTemperatureHeaterRate = Convert.ToSingle(args[0]);
                return true;
            });
            DATA.Subscribe($"{Module}.{Name}.DeviceData", () => DeviceData,SubscriptionAttribute.FLAG.IgnoreSaveDB);

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


            _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_DEVICE_INFO, Module, $"{Name} {_goPositionTime / 1000} s 内未到原点");
                }
            }
            else if (_originTimer.IsIdle() == false)
            {
                if (_diGoOriginFeedback.Value == true)
                {
                    LOG.Write(eEvent.EV_DEVICE_INFO, Module, $"{Name} 到 原点");
                    _doGoOriginOn.Value = false;
                    _originTimer.Stop();
                }
            }

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

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

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

            
            _SetRealFloat(_aoLiftServoPosition1, (float)SC.GetValue<double>($"{Module}.HighTemperatureChiller.LiftServoPosition1"));
            _SetRealFloat(_aoLiftServoPosition2, (float)SC.GetValue<double>($"{Module}.HighTemperatureChiller.LiftServoPosition2"));
            _SetRealFloat(_aoLiftServoPosition3, (float)SC.GetValue<double>($"{Module}.HighTemperatureChiller.LiftServoPosition3"));
            _SetRealFloat(_aoLiftServoPosition4, (float)SC.GetValue<double>($"{Module}.HighTemperatureChiller.LiftServoPosition4"));
            _SetRealFloat(_aoLiftServoPosition5, (float)SC.GetValue<double>($"{Module}.HighTemperatureChiller.LiftServoPosition5"));


          

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

         


        }
        public void Reset()
        {

        }
    }
}