using Aurora.Api.Devices;
using Hermes;
using System;
using System.Text;
using System.Threading;

namespace AuroraLaser
{
    class LaserNL202 : SerialConn, ILaser
    {
        private bool _IsSimul;
        protected const int MAX_PORT_NUMBER = 16;
        public const int MAX_SLAVES = 5;

        protected string LOG_TAG = "NL202";
        protected NL202Status _NL202Status;
        public bool _isLaserOn;
        public bool _checkLaserStandby;
        public bool _checkLaserMotorMoving;
        private static Mutex _mutexLaser = new Mutex(false, "MutexLaser");

        #region NL202 Enumarator Definitions
        public enum SendParam
        {
            NL202_Set_Run = 0,          //	-
            NL202_Set_Stop,             //	-
            NL202_Set_ResetFAULT,       //	-
            NL202_Set_OutLev,           //	OFF, Adjustment, Maximum
            NL202_Set_PumpLevel,        //	0..100
            NL202_Set_Wavelength,       //	1064nm, 532nm
            NL202_Set_BurstMode,        //	OFF, ON
            NL202_Set_Burstlenth,       //	1..65535
            NL202_Set_TriggerBurst,     //	Burst Mode Shot
            NL202_Set_AdjDelay,         //	100..1000
            NL202_Set_TTec1,            //	15.00 .. 35.00
            NL202_Set_SyncMode,         //	Internal, External
            NL202_Set_SH1Temp,          //	30.00 .. 70.0
            NL202_Set_AttnTrans,        //	0..100
            NL202_Set_RepetitionRate,   //	Frq 1..1000
            NL202_Set_MaxCnt
        };

        public enum ReadParam
        {
            NL202_Get_State = 0,        //	Idle, Running, Error, NotInitialized
            NL202_Get_FaultCode,        //	1..65535
            NL202_Get_FaultMsg,         //	%s
            NL202_Get_PumpLevel,        //	0..100
            NL202_Get_Wavelenth,        //	1064nm, 532nm
            NL202_Get_EnergyLevel,      //	OFF, Adjustment, Maximum
            NL202_Get_TTec1,            //	15.00 .. 35.00
            NL202_Get_BurstMode,        //	OFF, ON
            NL202_Get_QSWAdjDelay,      //	100..1000
            NL202_Get_BurstLenth,       //	1..65535
            NL202_Get_SyncMode,         //	Internal, External
            NL202_Get_SH1Temp,          //	30.00 .. 70.0
            NL202_Get_AttnTrans,        //	0..100
            NL202_Get_RepetitionRate,   // 확인필요 메뉴얼에는 없는내용임.
            NL202_Get_ShotCnt,          // 확인필요 메뉴얼에는 없는내용임.
            NL202_Get_MaxCnt
        };
        #endregion

        #region Status Class Definition
        public class NL202Status
        {
            public int State { get; set; }
            public int EnergyLevel { get; set; }
            public double PumpLevel { get; set; }
            public int QSWAdjustDelay { get; set; }
            public int SyncMode { get; set; }
            public int BurstMode { get; set; }               //0 == Off / 1 == ON
            public int BurstCount { get; set; }
            public int RepetitionRate { get; set; }
            public double Temperature_TTec1 { get; set; }
            public double Temperature_SH1 { get; set; }
            public int WaveLength { get; set; }
            public double AttenTrans { get; set; }
            public int FaultCode { get; set; }
            public string FaultMsg { get; set; }
            public int ShotCount { get; set; }
        };
        #endregion

        public LaserNL202(string deviceid, bool isSimul) : base(deviceid, isSimul)
        {
            _IsSimul = isSimul;
            if (_IsSimul) {
                _NL202Status.State = -1;
                _NL202Status.AttenTrans = new Random().NextDouble();
                _NL202Status.BurstCount = new Random().Next(0, 2);
                _NL202Status.BurstMode = new Random().Next(0, 2);
                _NL202Status.EnergyLevel = new Random().Next(0, 10);
                _NL202Status.FaultCode = new Random().Next(0, 100);
                _NL202Status.FaultMsg = "Random Fault Message : " + _NL202Status.FaultCode;
                _NL202Status.PumpLevel = new Random().NextDouble();
                _NL202Status.QSWAdjustDelay = new Random().Next(0, 10);
                _NL202Status.RepetitionRate = new Random().Next(0, 10);
                _NL202Status.ShotCount = new Random().Next(0, 10);
                _NL202Status.SyncMode = new Random().Next(0, 2);
                _NL202Status.Temperature_SH1 = new Random().NextDouble() * 20;
                _NL202Status.Temperature_TTec1 = new Random().NextDouble() * 20;
                _NL202Status.WaveLength = new Random().Next(0, 10);
            }
        }
        public int Open(LaserConfig Config)
        {
            if (_IsSimul) {
                return E1.OK;
            }
            var connConfig = Config.ConnConfig as SerialConnConfig;
            if (!IsConnected()) {
                if (connConfig.PortNum >= 0 && connConfig.PortNum <= MAX_PORT_NUMBER) {
                    return Open(connConfig);
                }
            }

            return Open(Config);
        }
        public void DisConnect()
        {
            if (_IsSimul) {
                return;
            }

            Close();
        }
        public bool GetConnected()
        {
            return IsConnected();
        }
        public int SetData(int nTarget, int value)
        {
            return E1.OK;
        }
        public string GetData(int nTarget)
        {
            return "";
        }

        public int LaserOn()
        {
            RunLaser();
            return 1;
        }

        public int LaserOff()
        {
            StopLaser();
            return 1;
        }
        public int PilotLaserOn()
        {
            // guide beam 이나 pilot laser 에 대한 함수가 없다.
            return 1;
        }

        public int PilotLaserOff()
        {
            // guide beam 이나 pilot laser 에 대한 함수가 없다.
            return 1;
        }
        public bool GetInitCommunication()
        {
            // 업데이트 예정
            return false;
        }
        public bool GetEmissionStatus()
        {
            // 업데이트 예정
            return false;
        }
        public bool GetLaserReady()
        {
            // 업데이트 예정
            return false;
        }
        public bool GetLaserError()
        {
            // 업데이트 예정
            return false;
        }
        public bool GetWariningStatus()
        {
            // 업데이트 예정
            return false;
        }
        // MAINS_STATUS, ERROR_STATUS 는 위에 있음
        public bool GetPilotLaserStatus()
        {
            // 업데이트 예정
            return false;
        }
        public string GetControlMode()
        {
            // 업데이트 예정
            return "";
        }
        public string GetPowerCenter()
        {
            // 업데이트 예정
            return "";
        }
        public string GetPowerRing()
        {
            // 업데이트 예정
            return "";
        }
        #region Set 명령 나간 bit 를 모니터링
        public bool GetStartLaserSetBitStatus()
        {

            // Laser Start 명령
            // 업데이트 예정
            return false;
        }
        public bool GetLaserStartSetBitStatus()
        {
            // Laser On 명령. Laser Emission Ready 를 위한 bit
            // 업데이트 예정
            return false;
        }
        public bool GetPilotLaserSetBitStatus()
        {
            // Pilot Laser On 명령.
            // 업데이트 예정
            return false;
        }
        public bool GetLaserResetSetBitStatus()
        {
            // Laser Reset 명령.
            // 업데이트 예정
            return false;
        }
        public bool GetControlModeSetStatus()
        {
            //  Control mode Local(false) Remote(true)
            // 업데이트 예정
            return false;
        }
        #endregion

        public int RS232_ReadBytes(ref byte[] readBuff, int size)
        {
            return Read(readBuff);
        }

        public const Int16 BUF_MAX = 32;
        protected const Int16 FAIL = -1;

        public int RS232_SendBuf(byte[] sendBuff, int length)
        {
            if (Write(sendBuff, length)) {
                return E1.OK;
            } else {
                return FAIL;
            }
        }

        public int RS232_SendByte(byte sendByte)
        {
            byte[] sendBuff = new byte[1];
            sendBuff[0] = sendByte;
            return RS232_SendBuf(sendBuff, 1);
        }

        public int RS232_SendString(SendParam index, double dValue = 0)  // RS232_cputs -> string으로 변경
        {
            string sendStr = GetSendCommand(index, dValue);
            if (sendStr.Length > 0) {
                byte[] sendBuff = Encoding.UTF8.GetBytes(sendStr);
                return RS232_SendBuf(sendBuff, sendBuff.Length);
            }
            return FAIL;
        }

        public int RS232_SendString(ReadParam index)  // RS232_cputs -> string으로 변경
        {
            string sendStr = GetReadCommand(index);
            if (sendStr.Length > 0) {
                byte[] sendBuff = Encoding.UTF8.GetBytes(sendStr);
                return RS232_SendBuf(sendBuff, sendBuff.Length);
            }
            return FAIL;
        }
        public string GetSendCommand(SendParam index, double dValue)
        {
            switch (index) {
                case SendParam.NL202_Set_Run:
                    return "/?EXE/Run\r\n";
                case SendParam.NL202_Set_Stop:
                    return "/?EXE/Stop\r\n";
                case SendParam.NL202_Set_ResetFAULT:
                    return "/?EXE/ResetFAULT\r\n";
                case SendParam.NL202_Set_OutLev:
                    if ((int)dValue == 0)
                        return "/?EXE/SetOutLev/OFF\r\n";
                    else if ((int)dValue == 1)
                        return "/?EXE/SetOutLev/Adjustment\r\n";
                    else if ((int)dValue == 2)
                        return "/?EXE/SetOutLev/Maximum\r\n";
                    break;
                case SendParam.NL202_Set_PumpLevel:
                    return "/?EXE/SetPumpLevel/" + ((int)dValue).ToString() + "\r\n";
                case SendParam.NL202_Set_Wavelength:
                    if ((int)dValue == 0)
                        return "/?EXE/SetWavelength/1064nm\r\n";
                    if ((int)dValue == 1)
                        return "/?EXE/SetWavelength/532nm\r\n";
                    break;
                case SendParam.NL202_Set_BurstMode:
                    if ((int)dValue == 0)
                        return "/?EXE/SetBurstMode/OFF\r\n";
                    else if ((int)dValue == 1)
                        return "/?EXE/SetBurstMode/ON\r\n";
                    break;
                case SendParam.NL202_Set_Burstlenth:
                    return "/?EXE/SetBurstLength/" + ((int)dValue + 1).ToString() + "\r\n";
                case SendParam.NL202_Set_TriggerBurst:
                    return "/?EXE/TriggerBurst/Trigger\r\n";
                case SendParam.NL202_Set_AdjDelay:
                    return "/?EXE/SetAdjDelay/" + ((int)dValue).ToString() + "\r\n";
                case SendParam.NL202_Set_TTec1:
                    return "/?EXE/SetTTec1/" + ((int)dValue).ToString() + "\r\n";
                case SendParam.NL202_Set_SyncMode:
                    //Internal, External
                    if ((int)dValue == 0)
                        return "/?EXE/SetSyncMode/Internal\r\n";
                    else if ((int)dValue == 1)
                        return "/?EXE/SetSyncMode/External\r\n";
                    break;
                case SendParam.NL202_Set_SH1Temp:
                    return "/?EXE/SetSH1Temp/" + ((int)dValue).ToString() + "\r\n";
                case SendParam.NL202_Set_AttnTrans:
                    return "/?EXE/SetAttnTrans/" + dValue.ToString("F2") + "\r\n";
                case SendParam.NL202_Set_RepetitionRate:
                    return "/?EXE/SetRepetitionRate/" + ((int)dValue).ToString() + "\r\n";
                default:
                    break;
            }
            return "";
        }

        public string GetReadCommand(ReadParam index)
        {
            switch (index) {
                case ReadParam.NL202_Get_State:
                    return "/?RDVAR/State\r\n";  //prepare command
                case ReadParam.NL202_Get_FaultCode:
                    return "/?RDVAR/FaultCode\r\n";  //prepare command
                case ReadParam.NL202_Get_FaultMsg:
                    return "/?RDVAR/FaultMsg\r\n";  //prepare command
                case ReadParam.NL202_Get_PumpLevel:
                    return "/?RDVAR/PumpLevel\r\n";  //prepare command
                case ReadParam.NL202_Get_Wavelenth:
                    return "/?RDVAR/Wavelength\r\n";  //prepare command
                case ReadParam.NL202_Get_EnergyLevel:
                    return "/?RDVAR/EnergyLevel\r\n";  //prepare command
                case ReadParam.NL202_Get_TTec1:
                    return "/?RDVAR/Temperature_TTec1\r\n";  //prepare command
                case ReadParam.NL202_Get_BurstMode:
                    return "/?RDVAR/BurstMode\r\n";  //prepare command
                case ReadParam.NL202_Get_QSWAdjDelay:
                    return "/?RDVAR/QSWAdjDelay\r\n";  //prepare command
                case ReadParam.NL202_Get_BurstLenth:
                    return "/?RDVAR/BurstLength\r\n";  //prepare command
                case ReadParam.NL202_Get_SyncMode:
                    return "/?RDVAR/SyncMode\r\n";  //prepare command
                case ReadParam.NL202_Get_SH1Temp:
                    return "/?RDVAR/SH1Temp\r\n";  //prepare command
                case ReadParam.NL202_Get_AttnTrans:
                    return "/?RDVAR/AttenTrans\r\n";  //prepare command
                case ReadParam.NL202_Get_RepetitionRate:
                    return "/?RDVAR/RepetitionRate\r\n";  //prepare command
                case ReadParam.NL202_Get_ShotCnt:
                    ///?RDVAR/TotalOpticalShots
                    return "/?RDVAR/TotalOpticalShots\r\n";  //prepare command
                default:
                    break;
            }
            return "";
        }

        // Simulation Only
        public void SetError(int errorCode, string errorMsg)
        {
            if (_IsSimul) {
                _NL202Status.FaultCode = errorCode;
                _NL202Status.FaultMsg = errorMsg;
            }
        }

        public bool GetLastError(ref int errorCode, ref string errorMsg)
        {
            errorCode = _NL202Status.FaultCode;
            errorMsg = _NL202Status.FaultMsg;
            return true;
        }

        public bool RunLaser()
        {
            if (_IsSimul) {
                _NL202Status.State = 1;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_Run, 0.0);
        }

        public bool StartBurstShot()
        {
            if (_IsSimul) {
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_TriggerBurst, 0.0);
        }

        public bool StopLaser()
        {
            if (_IsSimul) {
                _NL202Status.State = 0;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_Stop, 0.0);  // laser 상태를 Stop
        }

        public bool StopShot()
        {
            if (_IsSimul) {
                _NL202Status.State = 0;
                return true;
            }

            // 쏘고있는 레이저를 Stop
            bool bRet = SetLaserParam(SendParam.NL202_Set_Stop, 0.0);
            Thread.Sleep(500);
            bRet = SetLaserParam(SendParam.NL202_Set_SyncMode, 1);
            Thread.Sleep(500);
            bRet = SetLaserParam(SendParam.NL202_Set_Run, 0.0);
            Thread.Sleep(700);

            return bRet;
        }

        public bool ResetFault()
        {
            if (_IsSimul) {
                SetError(0, "");
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_ResetFAULT, 0.0);
        }

        public bool SetPumpLevel(double dValue)
        {
            if (_IsSimul) {
                _NL202Status.PumpLevel = dValue;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_PumpLevel, dValue);
        }

        public bool SetBurstCount(int nBurst)
        {
            if (_IsSimul) {
                _NL202Status.BurstCount = nBurst;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_Burstlenth, nBurst);
        }

        public bool SetBurstMode(int nFireMode)
        {
            if (_IsSimul) {
                _NL202Status.BurstMode = nFireMode;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_BurstMode, nFireMode);
        }

        public bool SetRepetitionRate(int nRepetition)
        {
            if (_IsSimul) {
                _NL202Status.RepetitionRate = nRepetition;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_RepetitionRate, nRepetition);
        }

        public bool SetEnergyLevel(int nMod)
        {
            if (_IsSimul) {
                _NL202Status.EnergyLevel = nMod;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_OutLev, nMod);
        }

        public bool SetWaveLength(int nWaveLength)
        {
            if (_IsSimul) {
                _NL202Status.WaveLength = nWaveLength;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_Wavelength, nWaveLength);
        }

        public bool SetAttenuator(double dValue)
        {
            if (_IsSimul) {
                _NL202Status.AttenTrans = dValue;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_AttnTrans, dValue);
        }

        public bool SetSyncMode(int nMode)
        {
            if (_IsSimul) {
                _NL202Status.SyncMode = nMode;
                return true;
            }
            return SetLaserParam(SendParam.NL202_Set_SyncMode, nMode);
        }

        public double GetTemperature(int diode)
        {
            //if (_isSimul) return new Random().NextDouble() * 20;

            if (diode == 0)
                return _NL202Status.Temperature_TTec1;
            else if (diode == 1)
                return _NL202Status.Temperature_SH1;
            else
                return 0.0;
        }


        public bool SetLaserParam(int nIndex, double dValue)
        {
            if (_IsSimul) {
                return true;
            }
            if (nIndex >= 0 && nIndex < (int)SendParam.NL202_Set_MaxCnt) {
                return SetLaserParam((SendParam)nIndex, dValue);
            } else {
                return false;
            }
        }

        public bool SetLaserParam(SendParam nIndex, double dValue)
        {
            if (_IsSimul) {
                return true;
            }

            _mutexLaser.WaitOne();

            //clear buffers : Aurora의 Serialconn은 Write 전에 내부적으로 ClearSerialPortInOutBuffers 수행하므로 불필요
            //_deviceNL202.RS232_flushRXTX();

            RS232_SendString(nIndex, dValue);

            _mutexLaser.ReleaseMutex();

            return true;
        }

        public bool GetLaserParam(int nIndex)
        {
            if (nIndex >= 0 && nIndex < (int)ReadParam.NL202_Get_MaxCnt) {
                return GetLaserParam((ReadParam)nIndex);
            } else {
                return false;
            }
        }

        public bool GetLaserParam(ReadParam nIndex)
        {
            //USES_CONVERSION;
            string strBuffer = "";
            string str = "";
            double dValue = 0.0;
            int nValue = 0;
            int n = 0;

            byte[] readBuff = new byte[BUF_MAX];

            _mutexLaser.WaitOne();

            Thread.Sleep(100);

            // 공통처리
            RS232_SendString(nIndex);                  //send command
            Thread.Sleep(50);
            n = RS232_ReadBytes(ref readBuff, 4095);   //read answer

            if (n > 0) {
                readBuff[n] = 0;
                strBuffer = readBuff.ToString();    // byte to string

                switch (nIndex) {
                    case ReadParam.NL202_Get_State:
                        str = strBuffer.Substring(4, n - 7);

                        if (str == "Idle")
                            _NL202Status.State = 0;
                        else if (str == "Running")
                            _NL202Status.State = 1;
                        else if (str == "Error")
                            _NL202Status.State = 2;
                        else if (str == "NotInitialized")
                            _NL202Status.State = 3;
                        else
                            break;  //return false;

                        break;

                    case ReadParam.NL202_Get_FaultCode:
                        str = strBuffer.Substring(2, n - 4);

                        nValue = Convert.ToInt32(str);
                        _NL202Status.FaultCode = nValue;

                        break;

                    case ReadParam.NL202_Get_FaultMsg:
                        str = strBuffer.Substring(2, n - 4);

                        _NL202Status.FaultMsg = str;

                        break;

                    case ReadParam.NL202_Get_PumpLevel:
                        str = strBuffer.Substring(2, n - 4);

                        //nValue = Convert.ToDouble(str);
                        nValue = Convert.ToInt32(str);
                        _NL202Status.PumpLevel = nValue;

                        break;

                    case ReadParam.NL202_Get_Wavelenth:
                        str = strBuffer.Substring(2, n - 6);
                        int ntmp = Convert.ToInt32(str);

                        if (ntmp == 532) {
                            nValue = 1;
                        } else if (ntmp == 1064) {
                            nValue = 0;
                        }

                        _NL202Status.WaveLength = nValue;

                        break;

                    case ReadParam.NL202_Get_EnergyLevel:
                        str = strBuffer.Substring(3, n - 5);

                        if (str == "OFF")
                            _NL202Status.EnergyLevel = 0;
                        else if (str == "Adjustment")
                            _NL202Status.EnergyLevel = 1;
                        else if (str == "Maximum")
                            _NL202Status.EnergyLevel = 2;
                        else
                            break;  //return false;

                        break;

                    case ReadParam.NL202_Get_TTec1:
                        str = strBuffer.Substring(2, n - 4);

                        dValue = Convert.ToDouble(str);//인티저변경
                        _NL202Status.Temperature_TTec1 = dValue;

                        break;

                    case ReadParam.NL202_Get_BurstMode:
                        str = strBuffer.Substring(3, n - 5);

                        if (str == "OFF")
                            _NL202Status.BurstMode = 0;
                        else if (str == "ON")
                            _NL202Status.BurstMode = 1;
                        else
                            break;  //return false;

                        break;

                    case ReadParam.NL202_Get_QSWAdjDelay:
                        str = strBuffer.Substring(2, n - 4);

                        nValue = Convert.ToInt32(str);
                        _NL202Status.QSWAdjustDelay = nValue;

                        break;

                    case ReadParam.NL202_Get_BurstLenth:
                        str = strBuffer.Substring(2, n - 4);

                        nValue = Convert.ToInt32(str);
                        _NL202Status.BurstCount = nValue - 1;

                        break;

                    case ReadParam.NL202_Get_SyncMode:
                        str = strBuffer.Substring(3, n - 5);

                        if (str == "Internal")
                            _NL202Status.SyncMode = 0;
                        else if (str == "External")
                            _NL202Status.SyncMode = 1;
                        else
                            break;  //return false;

                        break;

                    case ReadParam.NL202_Get_SH1Temp:
                        str = strBuffer.Substring(2, n - 4);

                        dValue = Convert.ToDouble(str);
                        _NL202Status.Temperature_SH1 = dValue;

                        break;

                    case ReadParam.NL202_Get_AttnTrans:
                        str = strBuffer.Substring(2, n - 4);

                        dValue = Convert.ToDouble(str);
                        _NL202Status.AttenTrans = dValue;

                        break;

                    case ReadParam.NL202_Get_RepetitionRate:
                        str = strBuffer.Substring(2, n - 4);

                        //nValue = Convert.ToDouble(str);
                        dValue = Convert.ToDouble(str);
                        _NL202Status.RepetitionRate = nValue;

                        break;

                    case ReadParam.NL202_Get_ShotCnt:
                        str = strBuffer.Substring(2, n - 4);

                        nValue = Convert.ToInt32(str);
                        _NL202Status.ShotCount = nValue;

                        break;

                    default:
                        break;
                }
            }

            _mutexLaser.ReleaseMutex();

            return true;
        }

        public void CheckLaserParmeter(int nSynMode, int nBurstMode, int nBurstCount, int nWaveLength, int nRepetitionRate, double dAtt)
        {
            if (_IsSimul) return;

            if (nSynMode != GetSyncMode()) {
                SetSyncMode(nSynMode);
            }
            if (nBurstMode != GetBurstMode()) {
                SetBurstMode(nBurstMode);
            }
            if (nBurstCount != GetBurstCount()) {
                SetBurstCount(nBurstCount);
            }
            if (nWaveLength != GetWaveLength()) {
                SetWaveLength(nWaveLength);
            }
            if (nRepetitionRate != GetRepetitionRate()) {
                SetRepetitionRate(nRepetitionRate);
            }
            if (dAtt != GetAttTrans()) {
                SetAttenuator(dAtt);
            }
            if (GetState() == 0) {
                RunLaser();
            }
        }

        public int GetState()
        {
            return _NL202Status.State;
        }

        public double GetPumpLevel()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.PumpLevel;
        }

        public int GetBurstCount()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.BurstCount;
        }

        public int GetBurstMode()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.BurstMode;
        }

        public double GetAttTrans()
        {
            //if (_isSimul) return new Random().NextDouble();
            return _NL202Status.AttenTrans;
        }

        public int GetRepetitionRate()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.RepetitionRate;
        }

        public int GetWaveLength()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.WaveLength;
        }

        public int GetEnergyLevel()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.EnergyLevel;
        }

        public int GetSyncMode()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.SyncMode;
        }

        public int GetQSWadjDelay()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.QSWAdjustDelay;
        }

        public int GetShotCnt()
        {
            //if (_isSimul) return new Random().Next(0, 2);
            return _NL202Status.ShotCount;
        }
    }
}