Triton_160/Common/Core/RT/Device/Unit/IoBoostPump.cs

using System;
using System.Xml;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;

namespace Aitex.Core.RT.Device.Unit
{
    public enum BoostPumpEnable
    {
        Disable = 0,
        Enable = 1,
    }

    public class IoBoostPump : BaseDevice, IDevice
    {
        private DIAccessor _diBoosterInvAlarm = null;
        private DIAccessor _diBoosterInvRun = null;
        private DIAccessor _diBreakerState;
        private DIAccessor _diPowerOn;

        private AOAccessor _aoBoosterEnable = null;
        private AOAccessor _aoBoosterSetPoint = null;

        private AIAccessor _aiInverterFrequency = null;

        private SCItem<double> _scPressureSetPointMaxValue = null;
        private SCItem<bool> _scEnableFrequency = null;
 
        public bool IsRunning
        {
            get
            {
                if (_diPowerOn != null)
                    return _diPowerOn.Value;

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

                return true;
            }
        }
 
        public bool IsError 
        { 
            get
            {
                return _diBoosterInvAlarm != null && _diBoosterInvAlarm.Value; 
            } 
        }

        public double PressureSetPointMax
        {
            get
            {
                if (_scPressureSetPointMaxValue == null)
                    return 760000;
                return _scPressureSetPointMaxValue.Value;
            }
        }

        [Subscription(AITBoostPumpDataPropertyName.EnableSetPoint)]   
        public double EnableSetPoint
        {
            get
            {
                if (_aoBoosterEnable == null)
                    return 0;
                return _aoBoosterEnable.Value;
            }
        }

        [Subscription(AITBoostPumpDataPropertyName.PressureSetPoint)]   
        public double PressureSetPoint
        {
            get
            {
                if (_aoBoosterSetPoint == null)
                    return 0;
                return _aoBoosterSetPoint.Value;
            }
        }

        [Subscription(AITBoostPumpDataPropertyName.InverterFrequency)]   
        public double InverterFrequency
        {
            get
            {
                if (_aiInverterFrequency == null)
                    return 0;
                return _aiInverterFrequency.Value;
            }
        }

        public bool EnableFrequency
        {
            get
            {
                return _scEnableFrequency == null || _scEnableFrequency.Value;
            }
        }

        private R_TRIG _trigError = new R_TRIG();
 
        public IoBoostPump(string module, XmlElement node)
        {
            base.Module = module;
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");

            _diBoosterInvAlarm = ParseDiNode("diBoosterInvAlarm", node);
            _diBoosterInvRun = ParseDiNode("diBoosterInvRun", node);
            _diBreakerState = ParseDiNode("diBreakerState", node);
            _diPowerOn = ParseDiNode("diBoosterPowerOn", node);

            _aoBoosterEnable = ParseAoNode("aoBoosterEnable", node);
            _aoBoosterSetPoint = ParseAoNode("aoBoosterSetPoint", node);

            _aiInverterFrequency = ParseAiNode("aiFrequency", node);

            _scPressureSetPointMaxValue = ParseScNodeDouble("scPressureSetPointMaxValue", node);
            _scEnableFrequency = ParseScNodeBool("scEnableFrequency", node);
        }

        public bool Initialize()
        {
            DATA.Subscribe(string.Format("Device.{0}.{1}", Module, Name), () =>
                    {
                        AITBoostPumpData data = new AITBoostPumpData()
                        {
                            DeviceName = Name,
                            DeviceSchematicId = DeviceID,
                            DisplayName = Display,
                            IsError = IsError,
                            IsRunning = IsRunning,
                            EnableSetPoint = EnableSetPoint,
                            PressureSetPoint = PressureSetPoint,
                            InverterFrequency = InverterFrequency,
                            PressureSetPointMax = PressureSetPointMax,
                            EnableFrequency = EnableFrequency,
                        };

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

            DEVICE.Register(String.Format("{0}.{1}", Name, AITBoostPumpOperation.SetEnable), (out string reason, int time, object[] param) =>
            {
                if (IsError)
                {
                    reason = string.Format("boost pump is in error state, recover before set enable");
                    return false;
                }

                int isEnable = Convert.ToInt16((string)param[0]);

                if ((isEnable != (int) BoostPumpEnable.Enable) && (isEnable != (int)BoostPumpEnable.Disable))
                {
                    reason = string.Format("boost pump set value {0} is not valid, should be 0 || 1", isEnable);
                    return false;
                }

                reason = string.Empty;

                _aoBoosterEnable.Value = isEnable;

                return true;
            });

            DEVICE.Register(String.Format("{0}.{1}", Name, AITBoostPumpOperation.SetPressure), (out string reason, int time, object[] param) =>
            {
                if (IsError)
                {
                    reason = string.Format("boost pump is in error state, recover before set pressure");
                    return false;
                }

                double pressureSetPoint = Convert.ToDouble((string)param[0]);

                if (pressureSetPoint > PressureSetPointMax)
                {
                    reason = string.Format("boost pump pressure set to {0} is not valid, should be less than {1}", pressureSetPoint, PressureSetPointMax);
                    return false;                
                }

                _aoBoosterSetPoint.Value = (float)pressureSetPoint;

                reason = string.Empty;

                return true;
            });
            return true;
        }

 
        public bool SetEnable(int enable)
        {
            if (IsError)
            {
                return false;
            }

            if ((enable != (int) BoostPumpEnable.Enable) && (enable != (int)BoostPumpEnable.Disable))
            {
                LOG.Error(string.Format("boost pump set value {0} is not valid, should be 0 || 1", enable));
                return false;
            }

            if (_aoBoosterEnable != null)
            {
                _aoBoosterEnable.Value = enable;
            }

            return true;
        }

        public bool SetPressure(double setpoint, out string reason)
        {
            if (setpoint > PressureSetPointMax)
            {
                reason = string.Format("boost pump setpoint {0}, should be less than {1}", setpoint, PressureSetPointMax);
                return false;
            }

            reason = string.Empty;
            _aoBoosterSetPoint.Value = (float)setpoint;

            return true;
        }

        public void Terminate()
        {
            
        }

        public void Monitor()
        {
            try
            {
                _trigError.CLK = IsError;
                if (_trigError.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Booster Inverter Alarm");
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
                throw ex;
            }

        }

        public void Reset()
        {
            _trigError.RST = true;
        }
    }
}