LGES-OC5-PtoP-Welder/AuroraDevices/AuroraLaser/Coherent/LapidLX/LaserRapidLX.cs

using Aurora.Api;
using Aurora.Api.Devices;
using Hermes;
using System.Linq;

namespace AuroraLaser.Coherent
{
    public enum eCoherentIRLaser
    {
        RapidLX
    }

    // IR
    public class LaserRapidLX : Device
    {
        LaserRapidLXTcp _LaserRapidLX;

        public int Trigger { get; private set; }
        public bool State { get; private set; }
        public int Burst { get; private set; }
        public int RepRate { get; private set; }
        public double Power { get; private set; }
        public double MonitorPower { get; private set; }
        public double MonitorSeed { get; private set; }
        public string Fault { get; private set; }
        public string Serial { get; private set; }
        public string FirmVer { get; private set; }
        public string Model { get; private set; }
        public string Status { get; private set; }
        public string Warning { get; private set; }

        public double Flow { get; private set; }
        public double Temp { get; private set; }

        public double SeederTime { get; private set; }
        public double HeadTime { get; private set; }

        public LaserRapidLX(string deviceId, bool isSimul)
        {
            IsSimul = isSimul;
            _LaserRapidLX = new LaserRapidLXTcp(deviceId, isSimul);
        }
        protected override int DoActivate(IDeviceConfig config)
        {
            if (IsSimul) {
                return E1.OK;
            }

            return _LaserRapidLX.OnInit(config.ConnConfig as SocketConnConfig);
        }

        protected override int DoDeactivate()
        {
            return _LaserRapidLX.OnClose();
        }

        public bool IsConnected()
        {
            if (!IsActivated) {
                return false;
            }

            IsCommError = _LaserRapidLX._IsCommError;
            if (IsCommError) {
                return false;
            }

            return true;
        }

        public int SetAlarmReset()
        {
            if (!IsActivated) {
                return E2.NOT_CONNECTED;
            }

            if (IsSimul) {
                return E1.OK;
            }

            return _LaserRapidLX.SetAlarmReset();
        }

        public int SetEmission(bool bEmission)
        {
            if (!IsActivated) {
                return E2.NOT_CONNECTED;
            }

            if (IsSimul) {
                State = bEmission;
                return E1.OK;
            }

            return _LaserRapidLX.SetEmission(bEmission);
        }

        public int SetPower(double dPower)
        {
            if (!IsActivated) {
                return E2.NOT_CONNECTED;
            }

            if (IsSimul) {
                Power = dPower;
                return E1.OK;
            }

            return _LaserRapidLX.SetPower(dPower);
        }

        public int SetRepRate(int iRepRate)
        {
            if (!IsActivated) {
                return E2.NOT_CONNECTED;
            }

            if (IsSimul) {
                RepRate = iRepRate;
                return E1.OK;
            }

            return _LaserRapidLX.SetRepRate(iRepRate);
        }

        public int SetBurst(int iBurst)
        {
            if (!IsActivated) {
                return E2.NOT_CONNECTED;
            }

            if (IsSimul) {
                Burst = iBurst;
                return E1.OK;
            }

            return _LaserRapidLX.SetBurst(iBurst);
        }

        public int SetTrigger(int iTrigger)
        {
            if (!IsActivated) {
                return E2.NOT_CONNECTED;
            }

            if (IsSimul) {
                Trigger = iTrigger;
                return E1.OK;
            }

            return _LaserRapidLX.SetTrigger(iTrigger);
        }

        public void UpdateStatus()
        {
            if (!IsActivated) {
                return;
            }

            var status = _LaserRapidLX.GetStatus();
            if (status == null) {
                return;
            }

            int iValue;
            double dValue;

            var strList = status.Split('r');
            for (int i = 0; i < strList.Count(); i++) {
                var splited = strList[i].Split('=');
                if (splited.Count() < 2) {
                    continue;
                }

                var command = splited[0];
                var strValue = splited[1];
                if (strValue.Length > 20) {
                    return;
                }

                switch (command) {
                    case "\nBURST":
                        if (int.TryParse(strValue, out iValue)) {
                            Burst = iValue;
                        }
                        break;
                    case "\nF":
                        Fault = strValue;
                        break;
                    case "\nW":
                        Warning = strValue;
                        break;
                    case "\nWF":
                        if (double.TryParse(strValue, out dValue)) {
                            Temp = dValue;
                        }
                        break;
                    case "\nSH":
                        if (double.TryParse(strValue, out dValue)) {
                            SeederTime = dValue;
                        }
                        break;
                    case "\nHH":
                        if (double.TryParse(strValue, out dValue)) {
                            HeadTime = dValue;
                        }
                        break;
                    case "\nRL":
                        if (double.TryParse(strValue, out dValue)) {
                            Power = dValue;
                        }
                        break;
                    case "\nPD4P":
                        if (double.TryParse(strValue, out dValue)) {
                            MonitorSeed = dValue;
                        }
                        break;
                    case "\nPOUT":
                        if (double.TryParse(strValue, out dValue)) {
                            MonitorPower = dValue;
                        }
                        break;
                    case "\nRRAMPSET":
                        if (int.TryParse(strValue, out iValue)) {
                            RepRate = iValue;
                        }
                        break;
                    case "\nPM":
                        if (int.TryParse(strValue, out iValue)) {
                            Trigger = iValue;
                        }
                        break;
                    case "\nSTATE":
                        if (int.TryParse(strValue, out iValue)) {
                            State = iValue == 1;
                        }
                        break;
                }
            }

        }
    }
}