using System;
using System.Collections;
using log4net;
using System.Threading;

namespace SA_LTT.Module
{
    #region Enum
    public enum SourcesType
    {
        INT,
        EXT,
    }

    public enum TemperaturePointType
    {
        SHG = 0x00,
        THG = 0x01,
        LD1 = 0x02,
        LD2 = 0x03,
        LD3 = 0x04,
    }

    public enum BurstFiringModeType
    {
        Continuous = 0x00,
        SingleShot = 0x01
    }

    public enum BurstTriggerSourceType
    {
        Command = 0x00,
        Gate = 0x01,
    }

    public enum DutyControlModeType
    {
        Fixed = 0x00,
        Track = 0x01,
    }
    #endregion

    // Laser Set Current, Gate Source 말고는 다 고정값으로 사용함.
    // 나머지는 사용 못하게 막으면됨. UI는 상태값만 표시.
    /// <summary>
    /// Company : Photonics Industries International, Inc.
    /// Site : www.Photonix.com.
    /// PI laser control class.
    /// </summary>
    public class PiLaser : ComPort
    {
        #region Enum
        public enum WriteCommand
        {
            EnableShutter = 0x04,
            SystemReset = 0x07,
            EnableLDD = 0x10,
            SetCurrent = 0x11,
            MaxCurrent = 0x14,
            PRF = 0x21,
            PRFSource = 0x23,
            GateSource = 0x24,
            PECSource = 0x25,
            FPKEnable = 0x27,
            FPKRampTime = 0x28,
            FPKRampRate = 0x29,
            LPKEnable = 0x2B,
            LPKRampTime = 0x2C,
            LPKRampRate = 0x2D,
            TemperatureSetPoint = 0x31,
            DutyControl = 0x53,
            DutyControlWidth = 0x54,
            PECLevel = 0x55,
            BurstStatus = 0x56,
            BurstCount = 0x57,
            BurstRate = 0x58,
            BurstCycles = 0x59,
            BurstFiringMode = 0x67,
            BurstTriggerSource = 0x68,
            DutyControlMode = 0x69,
        }

        public enum ReadCommand
        {
            EnableShutter = 0x04,
            ReadSoftFaults = 0x0C,
            ReadBoardFaults = 0x0D,
            ReadStatus = 0x0F,
            EnableLDD = 0x10,
            SetCurrent = 0x11,
            ReadActualCurrent = 0x12,
            ReadDiodeVoltage = 0x13,
            MaxCurrent = 0x14,
            LDDHours = 0x15,
            PRF = 0x21,
            PRFSource = 0x23,
            GateSource = 0x24,
            PECSource = 0x25,
            FPKEnable = 0x27,
            FPKRampTime = 0x28,
            FPKRampRate = 0x29,
            LPKEnable = 0x2B,
            LPKRampTime = 0x2C,
            LPKRampRate = 0x2D,
            TemperatureSetPoint = 0x31,
            ActualTemperature = 0x32,
            DutyControl = 0x53,
            DutyControlWidth = 0x54,
            PECLevel = 0x55,
            BurstStatus = 0x56,
            BurstCount = 0x57,
            BurstRate = 0x58,
            BurstCycles = 0x59,
            BurstFiringMode = 0x67,
            BurstTriggerSource = 0x68,
            DutyControlMode = 0x69,
            PowerMonitorReading = 0x71,
            FlowReading = 0x74,
            HumidityReading = 0x76,
            NetworkAddress = 0x98,
        }
        #endregion

        #region Property
        /// <summary>
        /// Current pi laser status.
        /// </summary>
        public PiLaserStatus CurrentPiLaserStatus
        {
            get
            {
                return _currentPiLaserStatus;
            }

            private set
            {
                _currentPiLaserStatus = value;
            }
        }
        #endregion

        #region Field
        private ILog _piLaserLogger = LogManager.GetLogger("PiLaser");
        private IEnumerator _piLaserReadCommands;

        private PiLaserStatus _currentPiLaserStatus;

        private Equipment _equipment;
        private Thread t_statusUpdate;
        private object _lockObject;
        private bool _isLock;
        #endregion

        #region Construct
        public PiLaser(Equipment equipment)
        {
            serialPort.PortName = "COM12";
            serialPort.BaudRate = 115200;
            serialPort.Parity = System.IO.Ports.Parity.None;
            serialPort.DataBits = 8;
            serialPort.StopBits = System.IO.Ports.StopBits.One;
            Terminator = "\r";

            _equipment = equipment;

            _lockObject = new object();
            _currentPiLaserStatus = new PiLaserStatus();

            t_statusUpdate = new Thread(statusUpdate);
            t_statusUpdate.Start();
        }
        #endregion

        #region Function
        public void statusUpdate()
        {
            while (_equipment.IsDisposed == false)
            {
                try
                {
                    Thread.Sleep(10);

                    if (IsOpen)
                    {
                        if (_piLaserReadCommands == null || !_piLaserReadCommands.MoveNext())
                        {
                            _piLaserReadCommands = PiLaserReads();
                        }
                        else
                        {
                            bool value = (bool)_piLaserReadCommands.Current;

                            if (value == false)
                            {
                                // Alarm : Communication Alarm.
                            }
                        }
                    }
                    else
                    {
                        // Interlock : Connection Alarm 발생시 동작 안되도록 변경.
                        if (!Open())
                        {
                            // Alarm : Connection Alarm.
                        }
                    }
                }
                catch (Exception e)
                {
                    EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
                }
            }
        }

        private void CheckSoftFaults()
        {

            if (CurrentPiLaserStatus.CurrentSoftFaults.HfSync)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0100_LASER_SOFT_FAULT_HFSYNC);
            }

            if (CurrentPiLaserStatus.CurrentSoftFaults.LddInterlock)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0101_LASER_SOFT_FAULT_LDD_INTERLOCK);
            }

            if (CurrentPiLaserStatus.CurrentSoftFaults.ShutterInterlock)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0102_LASER_SOFT_FAULT_SHUTTER_INTERLOCK);
            }

            if (CurrentPiLaserStatus.CurrentSoftFaults.LowExtFrequency)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0103_LASER_SOFT_FAULT_LOW_EXT_FREQUENCY);
            }
        }

        private void CheckBoardFaults()
        {
            if (CurrentPiLaserStatus.CurrentBoardFaults.Main)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0103_LASER_SOFT_FAULT_LOW_EXT_FREQUENCY);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.Common)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0105_LASER_BOARD_FAULT_COMMON);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.Temperature)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0106_LASER_BOARD_FAULT_TEMPERATURE);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.Sensor)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0107_LASER_BOARD_FAULT_SENSOR);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.PowerMonitor)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0108_LASER_BOARD_FAULT_POWER_MONITOR);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.Pulse)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0109_LASER_BOARD_FAULT_PULSE);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.Ldd)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0110_LASER_BOARD_FAULT_LDD);
            }

            if (CurrentPiLaserStatus.CurrentBoardFaults.Motor)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0111_LASER_BOARD_FAULT_MOTOR);
            }
        }

        private void CheckSystemFaults()
        {
            if (CurrentPiLaserStatus.CurrentSystemFaults.Memory)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0112_LASER_SYSTEM_FAULT_MEMORY);
            }

            if (CurrentPiLaserStatus.CurrentSystemFaults.SdCard)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0113_LASER_SYSTEM_FAULT_SDCARD);
            }

            if (CurrentPiLaserStatus.CurrentSystemFaults.BoardCommunication)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0114_LASER_SYSTEM_FAULT_BOARD_COMMUNICATION);
            }

            if (CurrentPiLaserStatus.CurrentSystemFaults.BoardState)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0115_LASER_SYSTEM_FAULT_BOARD_STATE);
            }
        }

        private void CheckGeneralAlarms()
        {
            if (CurrentPiLaserStatus.CurrentGeneralAlarms.Ldd1)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0116_LASER_GENERAL_ALARM_LDD1);
            }

            if (CurrentPiLaserStatus.CurrentGeneralAlarms.Ldd2)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0117_LASER_GENERAL_ALARM_LDD2);
            }

            if (CurrentPiLaserStatus.CurrentGeneralAlarms.Qsw)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0118_LASER_GENERAL_ALARM_QSW);
            }

            if (CurrentPiLaserStatus.CurrentGeneralAlarms.Flow)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0119_LASER_GENERAL_ALARM_FLOW);
            }

            if (CurrentPiLaserStatus.CurrentGeneralAlarms.Wet)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0120_LASER_GENERAL_ALARM_WET);
            }

            if (CurrentPiLaserStatus.CurrentGeneralAlarms.Humidity)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0121_LASER_GENERAL_ALARM_HUMIDITY);
            }

            if (CurrentPiLaserStatus.CurrentGeneralAlarms.HfSync)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0122_LASER_GENERAL_ALARM_HFSYNC);
            }
        }

        private void CheckTemperatureFaults()
        {
            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault0)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0123_LASER_TEMPERATURE_FAULT_0);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault1)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0124_LASER_TEMPERATURE_FAULT_1);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault2)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0125_LASER_TEMPERATURE_FAULT_2);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault3)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0126_LASER_TEMPERATURE_FAULT_3);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault4)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0127_LASER_TEMPERATURE_FAULT_4);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault5)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0128_LASER_TEMPERATURE_FAULT_5);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault6)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0129_LASER_TEMPERATURE_FAULT_6);
            }

            if (CurrentPiLaserStatus.CurrentTemperatureControlFaults.TemperatureControlFault7)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0130_LASER_TEMPERATURE_FAULT_7);
            }
        }

        private void CheckSystemStateFaults()
        {
            if(CurrentPiLaserStatus.CurrentSystemState.SoftFault)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0131_LASER_SOFT_FAULT);
            }

            if (CurrentPiLaserStatus.CurrentSystemState.HardFault)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0132_LASER_HARD_FAULT);
            }
        }
        
        //===============================     Write    ==========================================
        /// <summary>
        /// Write enable shutter.
        /// </summary>
        /// <param name="enable">true : Enable, false : Disable</param>
        /// <returns></returns>
        public bool WriteEnableShutter(bool enable)
        {
            if (_equipment.piLaser.CurrentPiLaserStatus.EnableShutter && enable == false)
            {
                if (_equipment.piLaser.CurrentPiLaserStatus.SetCurrent > 0)
                {
                    _equipment.alarmManager.Occur(AlarmCode.AL_0080_SET_CURRENT_IS_NOT_ZERO);
                    return false;
                }
            }

            var bytesData = new byte[1];

            if (enable)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.EnableShutter, bytesData);
        }

        /// <summary>
        /// System reset.
        /// </summary>
        /// <returns></returns>
        public bool WriteSystemReset()
        {
            return WriteData(WriteCommand.SystemReset);
        }
        
        /// <summary>
        /// Write enable laser diode driver.
        /// </summary>
        /// <param name="enable">true : Enable, false : Disable</param>
        /// <returns></returns>
        public bool WriteEnableLdd(bool enable)
        {
            if (_equipment.piLaser.CurrentPiLaserStatus.EnableLdd && enable == false)
            {
                if (_equipment.piLaser.CurrentPiLaserStatus.SetCurrent > 0)
                {
                    _equipment.alarmManager.Occur(AlarmCode.AL_0080_SET_CURRENT_IS_NOT_ZERO);
                    return false;
                }
            }

            var bytesData = new byte[1];

            if (enable)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.EnableLDD, bytesData);
        }

        /// <summary>
        /// Write set current.
        /// </summary>
        /// <param name="ampere"> 0 - 100 (A)</param>
        public bool WriteSetCurrent(double ampere)
        {
            if (CurrentPiLaserStatus.CurrentSystemStatus.LddOn == false)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0078_LDD_IS_NOT_ON);
                return false;
            }

            if (CurrentPiLaserStatus.CurrentSystemStatus.ShutterEnabled == false)
            {
                _equipment.alarmManager.Occur(AlarmCode.AL_0079_SHUTTER_IS_NOT_OPEN);
                return false;
            }

            //Unit : 0.01A
            ampere = ampere * 100;

            if (ampere > 10000) ampere = 10000;
            else if (ampere < 0) ampere = 0;

            var ushortAmpere = ushort.Parse(ampere.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortAmpere);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.SetCurrent, bytesData);
        }

        /// <summary>
        /// Write max current.
        /// </summary>
        /// <param name="ampere"> 0 - 100 (A)</param>
        public bool WriteMaxCurrent(double ampere)
        {
            //Unit : 0.01A
            ampere = ampere * 100;

            if (ampere > 10000) ampere = 10000;
            else if (ampere < 0) ampere = 0;

            var ushortAmpere = ushort.Parse(ampere.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortAmpere);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.MaxCurrent, bytesData);
        }

        /// <summary>
        /// Write pulse repetition frequency.
        /// </summary>
        /// <param name="hz"> 0 - 1000000 Hz</param>
        public bool WritePrf(int pulseRepetitionFrequency)
        {
            if (pulseRepetitionFrequency > 1000000) pulseRepetitionFrequency = 1000000;
            else if (pulseRepetitionFrequency < 0) pulseRepetitionFrequency = 0;

            var bytesData = new byte[3];

            var bytesPulseRepetitionFrequency = BitConverter.GetBytes(pulseRepetitionFrequency);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesPulseRepetitionFrequency);

            bytesData[0] = bytesPulseRepetitionFrequency[1];
            bytesData[1] = bytesPulseRepetitionFrequency[2];
            bytesData[2] = bytesPulseRepetitionFrequency[3];

            return WriteData(WriteCommand.PRF, bytesData);
        }

        /// <summary>
        /// Write pulse repetition frequency source.
        /// </summary>
        /// <param name="source">Source type</param>
        /// <returns></returns>
        public bool WritePrfSource(SourcesType source)
        {
            var bytesData = new byte[1];

            if (source == SourcesType.EXT)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.PRFSource, bytesData);
        }

        /// <summary>
        /// Write gate source.
        /// </summary>
        /// <param name="source">Source type</param>
        /// <returns></returns>
        public bool WriteGateSource(SourcesType source)
        {
            var bytesData = new byte[1];

            if (source == SourcesType.EXT)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.GateSource, bytesData);
        }

        /// <summary>
        /// Write pulse energy control source.
        /// </summary>
        /// <param name="source">Source type</param>
        /// <returns></returns>
        public bool WritePecSource(SourcesType source)
        {
            var bytesData = new byte[1];

            if (source == SourcesType.EXT)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.PECSource, bytesData);
        }

        /// <summary>
        /// Write first pulse kill enable.
        /// </summary>
        /// <param name="enable">true : Enable, false : Disable</param>
        /// <returns></returns>
        public bool WriteFpkEnable(bool enable)
        {
            var bytesData = new byte[1];

            if (enable)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.FPKEnable, bytesData);
        }

        /// <summary>
        /// Write first pulse kill ramp time.
        /// </summary>
        /// <param name="rampTime"> 0 - 655350 (ns)</param>
        public bool WriteFpkRampTime(int rampTime)
        {
            //Units : 10ns
            rampTime = (int)(rampTime * 0.1);

            if (rampTime > 65535) rampTime = 65535;
            else if (rampTime < 0) rampTime = 0;

            var ushortRampTime = ushort.Parse(rampTime.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortRampTime);
            
            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.FPKRampTime, bytesData);
        }

        /// <summary>
        /// Write first pulse kill ramp rate.
        /// </summary>
        /// <param name="rampRate"> 0 - 6553500 (ns)</param>
        public bool WriteFpkRampRate(int rampRate)
        {
            //Units : 100ns
            rampRate = (int)(rampRate * 0.01);

            if (rampRate > 65535) rampRate = 65535;
            else if (rampRate < 0) rampRate = 0;

            var ushortRampRate = ushort.Parse(rampRate.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortRampRate);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.FPKRampRate, bytesData);
        }

        /// <summary>
        /// Write lpk enable.
        /// </summary>
        /// <param name="enable">true : Enable, false : Disable</param>
        /// <returns></returns>
        public bool WriteLpkEnable(bool enable)
        {
            byte[] bytesData = new byte[1];

            if (enable)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.LPKEnable, bytesData);
        }

        /// <summary>
        /// Write lpk ramp time.
        /// </summary>
        /// <param name="rampTime"> 0 - 655350 (ns)</param>
        public bool WriteLpkRampTime(double rampTime)
        {
            //Units : 10ns.
            rampTime = rampTime * 0.1f;

            if (rampTime > 65535) rampTime = 65535;
            else if (rampTime < 0) rampTime = 0;

            var ushortRampTime = ushort.Parse(rampTime.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortRampTime);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.LPKRampTime, bytesData);
        }

        /// <summary>
        /// Write lpk ramp rate.
        /// </summary>
        /// <param name="rampRate"> 0 - 6553500 (ns)</param>
        public bool WriteLpkRampRate(int rampRate)
        {
            //Units : 100ns
            rampRate = (int)(rampRate * 0.01);

            if (rampRate > 65535) rampRate = 65535;
            else if (rampRate < 0) rampRate = 0;

            var ushortRampRate = ushort.Parse(rampRate.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortRampRate);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.LPKRampRate, bytesData);
        }

        /// <summary>
        /// Write temperature set point.
        /// </summary>
        /// <param name="temperaturePoint">Temperature point</param>
        /// <param name="temperature"> 0 - 160 ℃</param>
        /// <returns></returns>
        public bool WriteTemperatureSetPoint(TemperaturePointType temperaturePoint, double temperature)
        {
            //Units : 0.01℃
            temperature = temperature * 100;
            if (temperature > 16000) temperature = 16000;
            else if (temperature < 0) temperature = 0;

            var ushortTemperature = ushort.Parse(temperature.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortTemperature);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.TemperatureSetPoint, bytesData, (int)temperaturePoint);
        }

        /// <summary>
        /// Write duty contorl.
        /// </summary>
        /// <param name="enable"> true : Enable, false : Disable </param>
        /// <returns></returns>
        public bool WriteDutyControl(bool enable)
        {
            var bytesData = new byte[1];

            if (enable)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.DutyControl, bytesData);
        }

        /// <summary>
        /// Write duty control width.
        /// </summary>
        /// <param name="dutyControlWidth">0 - (1/PRF - 0.1us)</param>
        public bool WriteDutyControlWidth(double dutyControlWidth)
        {
            //Units : 0.1us
            dutyControlWidth = dutyControlWidth * 10;

            if (dutyControlWidth > 16777215) dutyControlWidth = 16777215;
            else if (dutyControlWidth < 0) dutyControlWidth = 0;

            var intDutyControlWidth = int.Parse(dutyControlWidth.ToString("F0"));

            var bytesData = new byte[3];

            var bytesDutyControlWidth = BitConverter.GetBytes(intDutyControlWidth);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesDutyControlWidth);

            bytesData[0] = bytesDutyControlWidth[1];
            bytesData[1] = bytesDutyControlWidth[2];
            bytesData[2] = bytesDutyControlWidth[3];

            return WriteData(WriteCommand.DutyControlWidth, bytesData);
        }

        /// <summary>
        /// Write pulse energy control level.
        /// </summary>
        /// <param name="pecLevel">0 - 100%</param>
        /// <returns></returns>
        public bool WritePecLevel(double pulseEnergyControlLevel)
        {
            //Units : 0.1%
            pulseEnergyControlLevel = pulseEnergyControlLevel * 10;

            if (pulseEnergyControlLevel > 1000) pulseEnergyControlLevel = 1000;
            else if (pulseEnergyControlLevel < 0) pulseEnergyControlLevel = 0;

            var ushortPulseEnergyControlLevel = ushort.Parse(pulseEnergyControlLevel.ToString("F0"));

            var bytesData = BitConverter.GetBytes(ushortPulseEnergyControlLevel);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.PECLevel, bytesData);
        }

        /// <summary>
        /// Write burst status.
        /// </summary>
        /// <param name="burstStatus">true : Enable, false : Disable</param>
        /// <returns></returns>
        public bool WriteBurstStatus(bool burstStatus)
        {
            var bytesData = new byte[1];

            if (burstStatus)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.BurstStatus, bytesData);
        }

        /// <summary>
        /// Write burst count.
        /// </summary>
        /// <param name="burstCount">from 1 to (Burst Rate -1)</param>
        public bool WriteBurstCount(ushort burstCount)
        {
            if (burstCount > 65535) burstCount = 65535;
            else if (burstCount < 1) burstCount = 1;

            var bytesData = BitConverter.GetBytes(burstCount);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.BurstCount, bytesData);
        }
        
        /// <summary>
        /// Write burst rate.
        /// </summary>
        /// <param name="rate">from 1 to 65535</param>
        public bool WriteBurstRate(ushort burstRate)
        {
            // integer divisor of PRF
            if (burstRate > 65535) burstRate = 65535;
            else if (burstRate < 1) burstRate = 1;

            var bytesData = BitConverter.GetBytes(burstRate);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.BurstRate, bytesData);
        }

        /// <summary>
        /// Write burst cycles.
        /// </summary>
        /// <param name="rate">from 1 to 65535 (number of bursts)</param>
        public bool WriteBurstCycles(ushort burstCycles)
        {
            if (burstCycles > 65535) burstCycles = 65535;
            else if (burstCycles < 1) burstCycles = 1;

            var bytesData = BitConverter.GetBytes(burstCycles);

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

            return WriteData(WriteCommand.BurstCycles, bytesData);
        }

        /// <summary>
        /// Write burst firing mode.
        /// </summary>
        /// <param name="burstFiringMode">Brust firing mode</param>
        /// <returns></returns>
        public bool WriteBurstFiringMode(BurstFiringModeType burstFiringMode)
        {
            var bytesData = new byte[1];

            if (burstFiringMode == BurstFiringModeType.SingleShot)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.BurstFiringMode, bytesData);
        }

        /// <summary>
        /// Write burst trigger source.
        /// </summary>
        /// <param name="source">Burst trigger source</param>
        /// <returns></returns>
        public bool WriteBurstTriggerSource(BurstTriggerSourceType burstTriggerSource)
        {
            var bytesData = new byte[1];

            if (burstTriggerSource == BurstTriggerSourceType.Gate)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.BurstTriggerSource, bytesData);
        }

        /// <summary>
        /// Write duty control mode.
        /// </summary>
        /// <param name="dutyControlMode">Duty control mode</param>
        /// <returns></returns>
        public bool WriteDutyControlMode(DutyControlModeType dutyControlMode)
        {
            var bytesData = new byte[1];

            if (dutyControlMode == DutyControlModeType.Track)
                bytesData[0] = 0x01;
            else
                bytesData[0] = 0x00;

            return WriteData(WriteCommand.DutyControlMode, bytesData);
        }

        //===============================     Read     ==========================================
        /// <summary>
        /// Read enable shutter.
        /// </summary>
        /// <returns></returns>
        public bool ReadEnableShutter()
        {
            var bytesData = ReadData(ReadCommand.EnableShutter);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.EnableShutter = bytesData[0] == 0x01;
                return true;
            }
        }

        /// <summary>
        /// Read soft fauls.
        /// </summary>
        /// <returns></returns>
        public bool ReadSoftFaults()
        {
            var bytesdata = ReadData(ReadCommand.ReadSoftFaults);

            if (bytesdata == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.ChangeSoftFaults(bytesdata[1]);
                CheckSoftFaults();
                return true;
            }
        }

        /// <summary>
        /// Read board faults.
        /// </summary>
        /// <returns></returns>
        public bool ReadBoardFaults()
        {
            var bytesData = ReadData(ReadCommand.ReadBoardFaults);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.ChangeBoardFaults(bytesData[1]);
                CheckBoardFaults();
                return true;
            }
        }
        
        /// <summary>
        /// Read status.
        /// </summary>
        /// <returns></returns>
        public bool ReadStatus()
        {
            var bytesData = ReadData(ReadCommand.ReadStatus);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.ChangeSystemStatus(bytesData[0]);
                _currentPiLaserStatus.ChangeSystemFaults(bytesData[1]);
                _currentPiLaserStatus.ChangeGeneralAlarms(bytesData[2]);
                _currentPiLaserStatus.ChangeTemperatureControlFaults(bytesData[3]);
                _currentPiLaserStatus.ChangeSystemState(bytesData[4]);

                CheckSystemFaults();
                CheckGeneralAlarms();
                CheckTemperatureFaults();
                CheckSystemStateFaults();
                return true;
            }
        }

        /// <summary>
        /// Read enable ldd.
        /// </summary>
        /// <returns></returns>
        public bool ReadEnableLdd()
        {
            var bytesData = ReadData(ReadCommand.EnableLDD);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.EnableLdd = bytesData[0] == 0x01;
                return true;
            }
        }

        /// <summary>
        /// Read set current.
        /// </summary>
        /// <returns></returns>
        public bool ReadSetCurrent()
        {
            var bytesData = ReadData(ReadCommand.SetCurrent);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian)
                    Array.Reverse(bytesData);

                _currentPiLaserStatus.SetCurrent = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read actual current.
        /// </summary>
        /// <returns></returns>
        public bool ReadActualCurrent()
        {
            var bytesData = ReadData(ReadCommand.ReadActualCurrent);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.ActualCurrent = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read diode voltage.
        /// </summary>
        /// <returns></returns>
        public bool ReadDiodeVoltage()
        {
            var bytesData = ReadData(ReadCommand.ReadDiodeVoltage);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.DiodeVoltage = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read max current.
        /// </summary>
        /// <returns></returns>
        public bool ReadMaxCurrent()
        {
            var bytesData = ReadData(ReadCommand.MaxCurrent);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.MaxCurrent = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read laser diode diver hours.
        /// </summary>
        /// <returns></returns>
        public bool ReadLddHours()
        {
            var bytesData = ReadData(ReadCommand.LDDHours);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.LddHours = BitConverter.ToInt32(bytesData, 0) * 0.1f;
                return true;
            }
        }

        /// <summary>
        /// Read pulse repetition frequency.
        /// </summary>
        /// <returns></returns>
        public bool ReadPrf()
        {
            var bytesData = ReadData(ReadCommand.PRF);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                var bytesPulseRepetitionFrequency = new byte[4];

                bytesPulseRepetitionFrequency[0] = 0;
                bytesPulseRepetitionFrequency[1] = bytesData[0];
                bytesPulseRepetitionFrequency[2] = bytesData[1];
                bytesPulseRepetitionFrequency[3] = bytesData[2];

                if (BitConverter.IsLittleEndian) Array.Reverse(bytesPulseRepetitionFrequency);

                _currentPiLaserStatus.Prf = BitConverter.ToInt32(bytesPulseRepetitionFrequency, 0);
                return true;
            }
        }

        /// <summary>
        /// Read pulse repetition frequency source.
        /// </summary>
        /// <returns></returns>
        public bool ReadPRFSource()
        {
            var bytesData = ReadData(ReadCommand.PRFSource);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.PrfSource = bytesData[0] == 0x01 ? SourcesType.EXT : SourcesType.INT;
                return true;
            }
        }

        /// <summary>
        /// Read gate source.
        /// </summary>
        /// <returns></returns>
        public bool ReadGateSource()
        {
            var bytesData = ReadData(ReadCommand.GateSource);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.GateSource = bytesData[0] == 0x01 ? SourcesType.EXT : SourcesType.INT;
                return true;
            }
        }

        /// <summary>
        /// Read pulse energy control source.
        /// </summary>
        /// <returns></returns>
        public bool ReadPecSource()
        {
            var bytesData = ReadData(ReadCommand.PECSource);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.PecSource = bytesData[0] == 0x01 ? SourcesType.EXT : SourcesType.INT;
                return true;
            }
        }

        /// <summary>
        /// Read first pulse kill enable.
        /// </summary>
        /// <returns></returns>
        public bool ReadFPKEnable()
        {
            var data_bytes = ReadData(ReadCommand.FPKEnable);

            if (data_bytes == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.FpkEnable = data_bytes[0] == 0x01;
                return true;
            }
        }

        /// <summary>
        /// Read first pulse kill ramp time.
        /// </summary>
        /// <returns></returns>
        public bool ReadFpkRampTime()
        {
            var bytesData = ReadData(ReadCommand.FPKRampTime);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.FpkRampTime = BitConverter.ToUInt16(bytesData, 0) * 10;
                return true;
            }
        }

        /// <summary>
        /// Read first pulse kill ramp rate.
        /// </summary>
        /// <returns></returns>
        public bool ReadFpkRampRate()
        {
            var bytesData = ReadData(ReadCommand.FPKRampRate);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.FpkRampRate = BitConverter.ToUInt16(bytesData, 0) * 100;
                return true;
            }
        }

        /// <summary>
        /// Read lpk enable.
        /// </summary>
        /// <returns></returns>
        public bool ReadLpkEnable()
        {
            var bytesData = ReadData(ReadCommand.LPKEnable);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.LpkEnable = bytesData[0] == 0x01;
                return true;
            }
        }

        /// <summary>
        /// Read lpk ramp time.
        /// </summary>
        /// <returns></returns>
        public bool ReadLpkRampTime()
        {
            var bytesData = ReadData(ReadCommand.LPKRampTime);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.LpkRampTime = BitConverter.ToUInt16(bytesData, 0) * 10;
                return true;
            }
        }

        /// <summary>
        /// Read lpk ramp rate.
        /// </summary>
        /// <returns></returns>
        public bool ReadLpkRampRate()
        {
            var bytesData = ReadData(ReadCommand.LPKRampRate);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.LpkRampRate = BitConverter.ToUInt16(bytesData, 0) * 100;
                return true;
            }
        }

        /// <summary>
        /// Read temperature set point.
        /// </summary>
        /// <param name="temperaturePoint">Temperature point</param>
        /// <returns></returns>
        public bool ReadTemperatureSetPoint(TemperaturePointType temperaturePoint)
        {
            var bytesData = ReadData(ReadCommand.TemperatureSetPoint, (byte)temperaturePoint);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                if(temperaturePoint == TemperaturePointType.SHG)
                    _currentPiLaserStatus.ShgTemperatureSetPoint = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                if (temperaturePoint == TemperaturePointType.THG)
                    _currentPiLaserStatus.ThgTemperatureSetPoint = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                if (temperaturePoint == TemperaturePointType.LD1)
                    _currentPiLaserStatus.LdTemperatureSetPoint = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read actual temperature.
        /// </summary>
        /// <param name="temperaturePoint">Temperature point</param>
        /// <returns></returns>
        public bool ReadActualTemperature(TemperaturePointType temperaturePoint)
        {
            var bytesData = ReadData(ReadCommand.ActualTemperature, (byte)temperaturePoint);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);
                
                if (temperaturePoint == TemperaturePointType.SHG)
                    _currentPiLaserStatus.ShgActualTemperature = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                if (temperaturePoint == TemperaturePointType.THG)
                    _currentPiLaserStatus.ThgActualTemperature = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                if (temperaturePoint == TemperaturePointType.LD1)
                    _currentPiLaserStatus.LdActualTemperature = BitConverter.ToInt16(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read duty control.
        /// </summary>
        /// <returns></returns>
        public bool ReadDutyControl()
        {
            var bytesData = ReadData(ReadCommand.DutyControl);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.DutyControl = bytesData[0] == 0x01;
                return true;
            }
        }

        /// <summary>
        /// Read duty control width.
        /// </summary>
        /// <returns></returns>
        public bool ReadDutyControlWidth()
        {
            var bytesData = ReadData(ReadCommand.DutyControlWidth);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                var bytesDutyControlWidth = new byte[4];

                bytesDutyControlWidth[0] = 0;
                bytesDutyControlWidth[1] = bytesData[0];
                bytesDutyControlWidth[2] = bytesData[1];
                bytesDutyControlWidth[3] = bytesData[2];

                if (BitConverter.IsLittleEndian) Array.Reverse(bytesDutyControlWidth);

                _currentPiLaserStatus.DutyControlWidth = BitConverter.ToInt32(bytesDutyControlWidth, 0) * 0.1f;
                return true;
            }
        }

        /// <summary>
        /// Read pulse energy control level.
        /// </summary>
        /// <returns></returns>
        public bool ReadPecLevel()
        {
            var bytesData = ReadData(ReadCommand.PECLevel);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                if (bytesData.Length < 2)
                {

                }
                else
                {
                    _currentPiLaserStatus.PecLevel = BitConverter.ToInt16(bytesData, 0) * 0.1f;
                }
                return true;
            }
        }

        /// <summary>
        /// Read burst status.
        /// </summary>
        /// <returns></returns>
        public bool ReadBurstStatus()
        {
            var bytesData = ReadData(ReadCommand.BurstStatus);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.BurstStatus = bytesData[0] == 0x01;
                return true;
            }
        }

        /// <summary>
        /// Read burst count.
        /// </summary>
        /// <returns></returns>
        public bool ReadBurstCount()
        {
            var bytesData = ReadData(ReadCommand.BurstCount);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.BurstCount = BitConverter.ToUInt16(bytesData, 0);
                return true;
            }
        }

        /// <summary>
        /// Read burst rate.
        /// </summary>
        /// <returns></returns>
        public bool ReadBurstRate()
        {
            var bytesData = ReadData(ReadCommand.BurstRate);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.BurstRate = BitConverter.ToUInt16(bytesData, 0);
                return true;
            }
        }

        /// <summary>
        /// Read burst cycles.
        /// </summary>
        /// <returns></returns>
        public bool ReadBurstCycles()
        {
            var bytesData = ReadData(ReadCommand.BurstCycles);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.BurstCycles = BitConverter.ToUInt16(bytesData, 0);
                return true;
            }
        }

        /// <summary>
        /// Read burst firing mode.
        /// </summary>
        /// <returns></returns>
        public bool ReadBurstFiringMode()
        {
            var bytesData = ReadData(ReadCommand.BurstFiringMode);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.BurstFiringMode = bytesData[0] == 0x01 ? BurstFiringModeType.SingleShot : BurstFiringModeType.Continuous;
                return true;
            }
        }

        /// <summary>
        /// Read burst trigger source.
        /// </summary>
        /// <returns></returns>
        public bool ReadBurstTriggerSource()
        {
            var bytesData = ReadData(ReadCommand.BurstTriggerSource);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.BurstTriggerSource = bytesData[0] == 0x01 ? BurstTriggerSourceType.Gate : BurstTriggerSourceType.Command;
                return true;
            }
        }

        /// <summary>
        /// Read duty control mode.
        /// </summary>
        /// <returns></returns>
        public bool ReadDutyControlMode()
        {
            var bytesData = ReadData(ReadCommand.DutyControlMode);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                _currentPiLaserStatus.DutyControlMode = bytesData[0] == 0x01 ? DutyControlModeType.Fixed : DutyControlModeType.Track;
                return true;
            }
        }

        /// <summary>
        /// Read power monitor reading.
        /// </summary>
        /// <returns></returns>
        public bool ReadPowerMonitorReading()
        {
            var bytesData = ReadData(ReadCommand.PowerMonitorReading);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.PowerMonitorReading = BitConverter.ToInt32(bytesData, 0) * 0.01f;
                return true;
            }
        }

        /// <summary>
        /// Read flow reading.
        /// </summary>
        /// <returns></returns>
        public bool ReadFlowReading()
        {
            var bytesData = ReadData(ReadCommand.FlowReading);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.FlowReading = BitConverter.ToUInt16(bytesData, 0) * 0.1f;
                return true;
            }
        }

        /// <summary>
        /// Read humidity reading.
        /// </summary>
        /// <returns></returns>
        public bool ReadHumidityReading()
        {
            var bytesData = ReadData(ReadCommand.HumidityReading);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.HumidityReading = BitConverter.ToUInt16(bytesData, 0);
                return true;
            }
        }

        /// <summary>
        /// Read network address
        /// </summary>
        /// <returns></returns>
        public bool ReadNetworkAddress()
        {
            var bytesData = ReadData(ReadCommand.NetworkAddress);

            if (bytesData == null)
            {
                return false;
            }
            else
            {
                if (BitConverter.IsLittleEndian) Array.Reverse(bytesData);

                _currentPiLaserStatus.IpAddress = $"{bytesData[0]:D3}.{bytesData[1]:D3}.{bytesData[2]:D3}.{bytesData[3]:D3}";
                _currentPiLaserStatus.SubnetMask = $"{bytesData[4]:D3}.{bytesData[5]:D3}.{bytesData[6]:D3}.{bytesData[7]:D3}";
                _currentPiLaserStatus.Gateway = $"{bytesData[8]:D3}.{bytesData[9]:D3}.{bytesData[10]:D3}.{bytesData[11]:D3}";
                return true;
            }
        }

        //=============================== 데이터 전송 기본 함수 ==========================================
        /// <summary>
        /// 기존 데이터에 Checksum 추가하여 byte배열로 반환.
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        private byte[] AddChecksum(byte[] data)
        {
            var bytesChecksum = new byte[data.Length + 2];

            data.CopyTo(bytesChecksum, 0);

            var checksum = new byte[2];

            int sum = 0;

            foreach(byte value in data)
            {
                sum = sum + value;
            }

            checksum[0] = (byte)(sum / 256);
            checksum[1] = (byte)(sum % 256);

            checksum.CopyTo(bytesChecksum, data.Length);

            return bytesChecksum;
        }
        
        /// <summary>
        /// 기존 데이터에 Checksum 추가하여 string 형태로 반환.
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        private string AddChecksum(string data)
        {
            string strChecksum = string.Empty;

            int byteLength = data.Length / 2;

            var bytes = new byte[byteLength];

            for(int i = 0; i < byteLength; i++)
            {
                bytes[i] = Convert.ToByte(data.Substring(i * 2, 2), 16);
            }

            var checksum_bytes = AddChecksum(bytes);

            for(int i = 0; i < checksum_bytes.Length; i++)
            {
                strChecksum += $"{checksum_bytes[i]:X2}";
            }

            return strChecksum;
        }

        /// <summary>
        /// Read 후 받은 데이터와 보낸 데이터의 Command가 일치하는지 확인.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="commands"></param>
        /// <returns></returns>
        private bool CheckCommand(byte data, Array commands)
        {
            foreach(var value in commands)
            {
                if(data == (int)value)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Read후 받은 데이터의 Checksum이 정확한지 확인.
        /// </summary>
        /// <param name="datas"></param>
        /// <returns></returns>
        private bool CheckChecksum(byte[] datas)
        {
            int dataSum = 0;
            int checksumSum = 0;

            var bytesChecksum = new byte[4];
            bytesChecksum[0] = 0;
            bytesChecksum[1] = 0;
            bytesChecksum[2] = datas[datas.Length - 2];
            bytesChecksum[3] = datas[datas.Length - 1];

            if (BitConverter.IsLittleEndian) Array.Reverse(bytesChecksum);

            checksumSum = BitConverter.ToInt32(bytesChecksum, 0);

            for(int i = 0; i < datas.Length - 2; i++)
            {
                dataSum += datas[i];
            }

            if(dataSum == checksumSum)
                return true;
            else
                return false;
        }

        /// <summary>
        /// Laser에 Read 명령어를 보낼 때 사용.
        /// </summary>
        /// <param name="command"></param>
        /// <param name="addressCode"></param>
        /// <returns></returns>
        private byte[] ReadData(ReadCommand command, int addressCode = -1)
        {
            if (!IsOpen)
            {
                //SicLogger.WritePiLaserLog($"================ Pi laser ({PortName}) is not opened. ===============");
                return null;
            }

            lock (_lockObject)
            {
                try
                {
                    while (_isLock)
                    {
                        Monitor.Wait(_lockObject);
                    }

                    _isLock = true;
                    
                    while ((DateTime.Now - checkDate).TotalSeconds < 0.1)
                    {

                    }

                    string strReceivedData = string.Empty;

                    string sendData;

                    if (addressCode == -1)
                        sendData = $"010000{(int)command:X2}";
                    else
                        sendData = $"0100{addressCode:X2}{(int)command:X2}";

                    sendData = AddChecksum(sendData) + "\r";

                    //SicLogger.WritePiLaserLog($"================ Read Data ===============");
                    //SicLogger.WritePiLaserLog($"[Send] >>> {sendData.Replace("\r", "")}");

                    var bytesReceivedData = WriteRead(sendData);

                    if (bytesReceivedData == null)
                    {
                        //SicLogger.WritePiLaserLog($"[Recv] <<< Recv is fail");
                        return null;
                    }
                    else
                    {
                        strReceivedData = bytesReceivedData.Replace("\r", "");
                    }

                    //SicLogger.WritePiLaserLog($"[Recv] <<< {strReceivedData}");

                    var bytesReceivedFormatData = new byte[strReceivedData.Length / 2];

                    for (int i = 0; i < bytesReceivedFormatData.Length; i++)
                    {
                        bytesReceivedFormatData[i] = Convert.ToByte(strReceivedData.Substring(i * 2, 2), 16);
                    }

                    if (!CheckCommand(bytesReceivedFormatData[3], Enum.GetValues(typeof(ReadCommand))))
                    {
                        //SicLogger.WritePiLaserLog($"Command is not exist.");
                        return null;
                    }

                    if (!CheckChecksum(bytesReceivedFormatData))
                    {
                        //SicLogger.WritePiLaserLog($"Checksum is fail");
                        return null;
                    }

                    var bytesData = new byte[bytesReceivedFormatData[1]];

                    for (int i = 0; i < bytesReceivedFormatData[1]; i++)
                    {
                        bytesData[i] = bytesReceivedFormatData[4 + i];
                    }

                    return bytesData;
                }
                catch(Exception e)
                {
                    EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
                    return null;
                }
                finally
                {
                    checkDate = DateTime.Now;
                    _isLock = false;

                    Monitor.Pulse(_lockObject);
                }
            }
        }

        /// <summary>
        /// Laser에 Write 명령어를 보낼 때 사용.
        /// </summary>
        /// <param name="command"></param>
        /// <param name="bytesData"></param>
        /// <param name="addressCode"></param>
        /// <returns></returns>

        DateTime checkDate = DateTime.Now;
        private bool WriteData(WriteCommand command, byte[] bytesData = null, int addressCode = -1)
        {
            if (!IsOpen)
            {
                //SicLogger.WritePiLaserLog($"================ Pi laser ({PortName}) is not opened. ===============");
                return false;
            }

            lock (_lockObject)
            {
                try
                {
                    while (_isLock)
                    {
                        Monitor.Wait(_lockObject);
                    }

                    _isLock = true;
                    
                    while ((DateTime.Now - checkDate).TotalSeconds < 0.1)
                    {

                    }

                    string write_data;

                    if (bytesData == null)
                    {
                        if (addressCode == -1)
                            write_data = $"000000{(int)command:X2}";
                        else
                            write_data = $"0000{addressCode:X2}{(int)command:X2}";
                    }
                    else
                    {
                        if (addressCode == -1)
                            write_data = $"00{bytesData.Length:X2}00{(int)command:X2}";
                        else
                            write_data = $"00{bytesData.Length:X2}{addressCode:X2}{(int)command:X2}";

                        foreach (byte data in bytesData)
                        {
                            write_data += $"{data:X2}";
                        }
                    }

                    write_data = AddChecksum(write_data) + "\r";

                    //SicLogger.WritePiLaserLog($"================ Write Data ===============");
                    //SicLogger.WritePiLaserLog($"[Send] >>> {write_data.Replace("\r", "")}");
                    Write(write_data);
                    return true;
                }
                catch (Exception e)
                {
                    EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
                    return false;
                }
                finally
                {
                    checkDate = DateTime.Now;
                    _isLock = false;
                    Monitor.Pulse(_lockObject);
                }
            }
        }
        
        /// <summary>
        /// Pi laser read method 순차적으로 불러우는 함수.
        /// </summary>
        /// <returns></returns>
        public IEnumerator PiLaserReads()
        {
            yield return ReadStatus();
            yield return ReadBoardFaults();
            yield return ReadSoftFaults();
            yield return ReadEnableShutter();
            yield return ReadEnableLdd();
            yield return ReadSetCurrent();
            yield return ReadActualCurrent();
            yield return ReadDiodeVoltage();
            yield return ReadMaxCurrent();
            yield return ReadLddHours();
            yield return ReadPrf();
            yield return ReadPRFSource();
            yield return ReadGateSource();
            yield return ReadPecSource();
            yield return ReadFPKEnable();
            yield return ReadFpkRampTime();
            yield return ReadFpkRampRate();
            yield return ReadLpkEnable();
            yield return ReadLpkRampTime();
            yield return ReadLpkRampRate();
            yield return ReadTemperatureSetPoint(TemperaturePointType.SHG);
            yield return ReadTemperatureSetPoint(TemperaturePointType.THG);
            yield return ReadTemperatureSetPoint(TemperaturePointType.LD1);
            yield return ReadActualTemperature(TemperaturePointType.SHG);
            yield return ReadActualTemperature(TemperaturePointType.THG);
            yield return ReadActualTemperature(TemperaturePointType.LD1);
            yield return ReadDutyControl();
            yield return ReadDutyControlWidth();
            yield return ReadPecLevel();
            yield return ReadBurstStatus();
            yield return ReadBurstCount();
            yield return ReadBurstRate();
            yield return ReadBurstFiringMode();
            yield return ReadBurstTriggerSource();
            yield return ReadDutyControlMode();
            yield return ReadPowerMonitorReading();
            yield return ReadFlowReading();
            yield return ReadHumidityReading();
            //yield return _piLaser.ReadNetworkAddress();
        }
        #endregion
    }

    /// <summary>
    /// Pi laser status.
    /// </summary>
    public class PiLaserStatus
    {
        #region Define
        public struct SoftFaults
        {
            #region Property
            public bool HfSync
            {
                get
                {
                    return _hfSync;
                }

                set
                {
                    _hfSync = value;
                }
            }

            public bool LddInterlock
            {
                get
                {
                    return _lddInterlock;
                }

                set
                {
                    _lddInterlock = value;
                }
            }

            public bool ShutterInterlock
            {
                get
                {
                    return _shutterInterlock;
                }

                set
                {
                    _shutterInterlock = value;
                }
            }

            public bool LowExtFrequency
            {
                get
                {
                    return _lowExtFrequency;
                }

                set
                {
                    _lowExtFrequency = value;
                }
            }
            #endregion

            #region Field
            private bool _hfSync;
            private bool _lddInterlock;
            private bool _shutterInterlock;
            private bool _lowExtFrequency;
            #endregion
        }

        public struct BoardFaults
        {
            #region Property
            public bool Main
            {
                get
                {
                    return _main;
                }

                set
                {
                    _main = value;
                }
            }

            public bool Common
            {
                get
                {
                    return _common;
                }

                set
                {
                    _common = value;
                }
            }

            public bool Temperature
            {
                get
                {
                    return _temperature;
                }

                set
                {
                    _temperature = value;
                }
            }

            public bool Sensor
            {
                get
                {
                    return _sensor;
                }

                set
                {
                    _sensor = value;
                }
            }

            public bool PowerMonitor
            {
                get
                {
                    return _powerMonitor;
                }

                set
                {
                    _powerMonitor = value;
                }
            }

            public bool Pulse
            {
                get
                {
                    return _pulse;
                }

                set
                {
                    _pulse = value;
                }
            }

            public bool Ldd
            {
                get
                {
                    return _ldd;
                }

                set
                {
                    _ldd = value;
                }
            }

            public bool Motor
            {
                get
                {
                    return _motor;
                }

                set
                {
                    _motor = value;
                }
            }
            #endregion

            #region Field
            private bool _main;
            private bool _common;
            private bool _temperature;
            private bool _sensor;
            private bool _powerMonitor;
            private bool _pulse;
            private bool _ldd;
            private bool _motor;
            #endregion
        }

        public struct SystemStatus
        {
            #region Property
            /// <summary>
            /// Power On
            /// </summary>
            public bool PowerOn
            {
                get
                {
                    return _powerOn;
                }

                set
                {
                    _powerOn = value;
                }
            }

            /// <summary>
            /// Shutter Enabled
            /// </summary>
            public bool ShutterEnabled
            {
                get
                {
                    return _shutterEnabled;
                }

                set
                {
                    _shutterEnabled = value;
                }
            }

            /// <summary>
            /// Key Switch
            /// </summary>
            public bool KeySwitch
            {
                get
                {
                    return _keySwitch;
                }

                set
                {
                    _keySwitch = value;
                }
            }

            /// <summary>
            /// Laser Diode Drive On
            /// </summary>
            public bool LddOn
            {
                get
                {
                    return _lddOn;
                }

                set
                {
                    _lddOn = value;
                }
            }

            /// <summary>
            /// Q Switch On
            /// </summary>
            public bool QswOn
            {
                get
                {
                    return _qswOn;
                }

                set
                {
                    _qswOn = value;
                }
            }

            /// <summary>
            /// Shutter Interlock
            /// </summary>
            public bool ShutterInterlock
            {
                get
                {
                    return _shutterInterlock;
                }

                set
                {
                    _shutterInterlock = value;
                }
            }

            /// <summary>
            /// Laser Diode Drive Interlock
            /// </summary>
            public bool LddInterlock
            {
                get
                {
                    return _lddInterlock;
                }

                set
                {
                    _lddInterlock = value;
                }
            }
            #endregion

            #region Field
            private bool _powerOn;
            private bool _shutterEnabled;
            private bool _keySwitch;
            private bool _lddOn;
            private bool _qswOn;
            private bool _shutterInterlock;
            private bool _lddInterlock;
            #endregion
        }
        
        public struct SystemFaults
        {
            #region Property
            public bool Memory
            {
                get
                {
                    return _memory;
                }

                set
                {
                    _memory = value;
                }
            }

            public bool SdCard
            {
                get
                {
                    return _sdCard;
                }

                set
                {
                    _sdCard = value;
                }
            }

            public bool BoardCommunication
            {
                get
                {
                    return _boardCommunication;
                }

                set
                {
                    _boardCommunication = value;
                }
            }

            public bool BoardState
            {
                get
                {
                    return _boardState;
                }

                set
                {
                    _boardState = value;
                }
            }
            #endregion

            #region Field
            private bool _memory;
            private bool _sdCard;
            private bool _boardCommunication;
            private bool _boardState;
            #endregion
        }

        public struct GeneralAlarms
        {
            #region Property
            public bool Ldd1
            {
                get
                {
                    return _ldd1;
                }

                set
                {
                    _ldd1 = value;
                }
            }

            public bool Ldd2
            {
                get
                {
                    return _ldd2;
                }

                set
                {
                    _ldd2 = value;
                }
            }

            public bool Qsw
            {
                get
                {
                    return _qsw;
                }

                set
                {
                    _qsw = value;
                }
            }

            public bool Flow
            {
                get
                {
                    return _flow;
                }

                set
                {
                    _flow = value;
                }
            }

            public bool Wet
            {
                get
                {
                    return _wet;
                }

                set
                {
                    _wet = value;
                }
            }

            public bool Humidity
            {
                get
                {
                    return _humidity;
                }

                set
                {
                    _humidity = value;
                }
            }

            public bool HfSync
            {
                get
                {
                    return _hfSync;
                }

                set
                {
                    _hfSync = value;
                }
            }
            #endregion

            #region Field
            private bool _ldd1;
            private bool _ldd2;
            private bool _qsw;
            private bool _flow;
            private bool _wet;
            private bool _humidity;
            private bool _hfSync;
            #endregion
        }

        public struct TemperatureControlFaults
        {
            #region Property
            public bool TemperatureControlFault0
            {
                get
                {
                    return _temperatureControlFault0;
                }

                set
                {
                    _temperatureControlFault0 = value;
                }
            }

            public bool TemperatureControlFault1
            {
                get
                {
                    return _temperatureControlFault1;
                }

                set
                {
                    _temperatureControlFault1 = value;
                }
            }

            public bool TemperatureControlFault2
            {
                get
                {
                    return _temperatureControlFault2;
                }

                set
                {
                    _temperatureControlFault2 = value;
                }
            }

            public bool TemperatureControlFault3
            {
                get
                {
                    return _temperatureControlFault3;
                }

                set
                {
                    _temperatureControlFault3 = value;
                }
            }

            public bool TemperatureControlFault4
            {
                get
                {
                    return _temperatureControlFault4;
                }

                set
                {
                    _temperatureControlFault4 = value;
                }
            }

            public bool TemperatureControlFault5
            {
                get
                {
                    return _temperatureControlFault5;
                }

                set
                {
                    _temperatureControlFault5 = value;
                }
            }

            public bool TemperatureControlFault6
            {
                get
                {
                    return _temperatureControlFault6;
                }

                set
                {
                    _temperatureControlFault6 = value;
                }
            }

            public bool TemperatureControlFault7
            {
                get
                {
                    return _temperatureControlFault7;
                }

                set
                {
                    _temperatureControlFault7 = value;
                }
            }
            #endregion

            #region Field
            private bool _temperatureControlFault0;
            private bool _temperatureControlFault1;
            private bool _temperatureControlFault2;
            private bool _temperatureControlFault3;
            private bool _temperatureControlFault4;
            private bool _temperatureControlFault5;
            private bool _temperatureControlFault6;
            private bool _temperatureControlFault7;
            #endregion
        }

        public struct SystemState
        {
            #region Property
            public bool SystemInitialization
            {
                get
                {
                    return _systemInitialization;
                }

                set
                {
                    _systemInitialization = value;
                }
            }

            public bool Setup
            {
                get
                {
                    return _setup;
                }

                set
                {
                    _setup = value;
                }
            }

            public bool Running
            {
                get
                {
                    return _running;
                }

                set
                {
                    _running = value;
                }
            }

            public bool Standby
            {
                get
                {
                    return _standby;
                }

                set
                {
                    _standby = value;
                }
            }

            public bool SoftFault
            {
                get
                {
                    return _softFault;
                }

                set
                {
                    _softFault = value;
                }
            }

            public bool HardFault
            {
                get
                {
                    return _hardFault;
                }

                set
                {
                    _hardFault = value;
                }
            }
            #endregion

            #region Field
            private bool _systemInitialization;
            private bool _setup;
            private bool _running;
            private bool _standby;
            private bool _softFault;
            private bool _hardFault;
            #endregion
        }
        #endregion

        #region Property
        /// <summary>
        /// Current soft faults.
        /// </summary>
        public SoftFaults CurrentSoftFaults
        {
            get
            {
                return _currentSoftFaults;
            }

            private set
            {
                _currentSoftFaults = value;
            }
        }

        /// <summary>
        /// Current board faults.
        /// </summary>
        public BoardFaults CurrentBoardFaults
        {
            get
            {
                return _currentBoardFaults;
            }

            private set
            {
                _currentBoardFaults = value;
            }
        }

        /// <summary>
        /// current system status.
        /// </summary>
        public SystemStatus CurrentSystemStatus
        {
            get
            {
                return _currentSystemStatus;
            }

            private set
            {
                _currentSystemStatus = value;
            }
        }

        /// <summary>
        /// curerent system faults.
        /// </summary>
        public SystemFaults CurrentSystemFaults
        {
            get
            {
                return _currentSystemFaults;
            }

            private set
            {
                _currentSystemFaults = value;
            }
        }

        /// <summary>
        /// Current general alarms.
        /// </summary>
        public GeneralAlarms CurrentGeneralAlarms
        {
            get
            {
                return _currentGeneralAlarms;
            }

            private set
            {
                _currentGeneralAlarms = value;
            }
        }

        /// <summary>
        /// Current temperature control faults.
        /// </summary>
        public TemperatureControlFaults CurrentTemperatureControlFaults
        {
            get
            {
                return _currentTemperatureControlFaults;
            }

            private set
            {
                _currentTemperatureControlFaults = value;
            }
        }

        /// <summary>
        /// Current systems state.
        /// </summary>
        public SystemState CurrentSystemState
        {
            get
            {
                return _currentSystemState;
            }

            private set
            {
                _currentSystemState = value;
            }
        }

        /// <summary>
        /// Enable shutter (true : Enable, false : Disable).
        /// </summary>
        public bool EnableShutter
        {
            get
            {
                return _enableShutter;
            }

            set
            {
                _enableShutter = value;
            }
        }

        /// <summary>
        /// Enable Laser diode driver (true : Enable, false : Disable).
        /// </summary>
        public bool EnableLdd
        {
            get
            {
                return _enableLdd;
            }

            set
            {
                _enableLdd = value;
            }
        }

        /// <summary>
        /// Set current (A).
        /// </summary>
        public float SetCurrent
        {
            get
            {
                return _setCurrent;
            }

            set
            {
                _setCurrent = value;
            }
        }

        /// <summary>
        /// Actual current (A).
        /// </summary>
        public float ActualCurrent
        {
            get
            {
                return _actualCurrent;
            }

            set
            {
                _actualCurrent = value;
            }
        }

        /// <summary>
        /// Diode voltage (V).
        /// </summary>
        public float DiodeVoltage
        {
            get
            {
                return _diodeVoltage;
            }

            set
            {
                _diodeVoltage = value;
            }
        }

        /// <summary>
        /// Max current (A).
        /// </summary>
        public float MaxCurrent
        {
            get
            {
                return _maxCurrent;
            }

            set
            {
                _maxCurrent = value;
            }
        }

        /// <summary>
        /// Laser diode driver hours (Hour).
        /// </summary>
        public float LddHours
        {
            get
            {
                return _lddHours;
            }

            set
            {
                _lddHours = value;
            }
        }

        /// <summary>
        /// Pulse Repetition Frequency (Hz).
        /// </summary>
        public int Prf
        {
            get
            {
                return _prf;
            }

            set
            {
                _prf = value;
            }
        }

        /// <summary>
        /// Pulse repetition frequency source.
        /// </summary>
        public SourcesType PrfSource
        {
            get
            {
                return _prfSource;
            }

            set
            {
                _prfSource = value;
            }
        }

        /// <summary>
        /// Gate source.
        /// </summary>
        public SourcesType GateSource
        {
            get
            {
                return _gateSource;
            }

            set
            {
                _gateSource = value;
            }
        }

        /// <summary>
        /// Pulse energy control source.
        /// </summary>
        public SourcesType PecSource
        {
            get
            {
                return _pecSource;
            }

            set
            {
                _pecSource = value;
            }
        }

        /// <summary>
        /// First pulse kill enable (true : Enable, false : Disable).
        /// </summary>
        public bool FpkEnable
        {
            get
            {
                return _fpkEnable;
            }

            set
            {
                _fpkEnable = value;
            }
        }

        /// <summary>
        /// First pulse kill Time (ns).
        /// </summary>
        public int FpkRampTime
        {
            get
            {
                return _fpkRampTime;
            }

            set
            {
                _fpkRampTime = value;
            }
        }

        /// <summary>
        /// First pulse kill Ramp Rate (ns)
        /// </summary>
        public int FpkRampRate
        {
            get
            {
                return _fpkRampRate;
            }

            set
            {
                _fpkRampRate = value;
            }
        }

        /// <summary>
        /// Lpk Enable (true : Enable, false : Disable).
        /// </summary>
        public bool LpkEnable
        {
            get
            {
                return _lpkEnable;
            }

            set
            {
                _lpkEnable = value;
            }
        }

        /// <summary>
        /// LPK Ramp Time (ns).
        /// </summary>
        public int LpkRampTime
        {
            get
            {
                return _lpkRampTime;
            }

            set
            {
                _lpkRampTime = value;
            }
        }

        /// <summary>
        /// LPK Ramp Rate (ns).
        /// </summary>
        public int LpkRampRate
        {
            get
            {
                return _lpkRampRate;
            }

            set
            {
                _lpkRampRate = value;
            }
        }

        /// <summary>
        /// Shg temperature set point (℃).
        /// </summary>
        public float ShgTemperatureSetPoint
        {
            get
            {
                return _shgTemperatureSetPoint;
            }

            set
            {
                _shgTemperatureSetPoint = value;
            }
        }

        /// <summary>
        /// Thg temperature set point (℃).
        /// </summary>
        public float ThgTemperatureSetPoint
        {
            get
            {
                return _thgTemperatureSetPoint;
            }

            set
            {
                _thgTemperatureSetPoint = value;
            }
        }

        /// <summary>
        /// Ld temperature set point (℃).
        /// </summary>
        public float LdTemperatureSetPoint
        {
            get
            {
                return _ldTemperatureSetPoint;
            }

            set
            {
                _ldTemperatureSetPoint = value;
            }
        }


        /// <summary>
        /// Shg actual temperature (℃).
        /// </summary>
        public float ShgActualTemperature
        {
            get
            {
                return _shgActualTemperature;
            }

            set
            {
                _shgActualTemperature = value;
            }
        }

        /// <summary>
        /// Thg actual temperature (℃).
        /// </summary>
        public float ThgActualTemperature
        {
            get
            {
                return _thgActualTemperature;
            }

            set
            {
                _thgActualTemperature = value;
            }
        }

        /// <summary>
        /// Laser diode actual temperature (℃).
        /// </summary>
        public float LdActualTemperature
        {
            get
            {
                return _ldActualTemperature;
            }

            set
            {
                _ldActualTemperature = value;
            }
        }

        /// <summary>
        /// Duty control (true : Enable, false : Disable).
        /// </summary>
        public bool DutyControl
        {
            get
            {
                return _dutyControl;
            }

            set
            {
                _dutyControl = value;
            }
        }

        /// <summary>
        /// Duty control width (us).
        /// </summary>
        public float DutyControlWidth
        {
            get
            {
                return _dutyControlWidth;
            }

            set
            {
                _dutyControlWidth = value;
            }
        }

        /// <summary>
        /// Pulse energy control level (%).
        /// </summary>
        public float PecLevel
        {
            get
            {
                return _pecLevel;
            }

            set
            {
                _pecLevel = value;
            }
        }

        /// <summary>
        /// Burst status (true : Enable, false : Disable).
        /// </summary>
        public bool BurstStatus
        {
            get
            {
                return _burstStatus;
            }

            set
            {
                _burstStatus = value;
            }
        }

        /// <summary>
        /// Burst count.
        /// </summary>
        public ushort BurstCount
        {
            get
            {
                return _burstCount;
            }

            set
            {
                _burstCount = value;
            }
        }

        /// <summary>
        /// Burst rate.
        /// </summary>
        public ushort BurstRate
        {
            get
            {
                return _burstRate;
            }

            set
            {
                _burstRate = value;
            }
        }

        /// <summary>
        /// Burst cycles.
        /// </summary>
        public ushort BurstCycles
        {
            get
            {
                return _burstCycles;
            }

            set
            {
                _burstCycles = value;
            }
        }

        /// <summary>
        /// Burst firing mode.
        /// </summary>
        public BurstFiringModeType BurstFiringMode
        {
            get
            {
                return _burstFiringMode;
            }

            set
            {
                _burstFiringMode = value;
            }
        }

        /// <summary>
        /// Burst trigger source.
        /// </summary>
        public BurstTriggerSourceType BurstTriggerSource
        {
            get
            {
                return _burstTriggerSource;
            }

            set
            {
                _burstTriggerSource = value;
            }
        }

        /// <summary>
        /// Duty control mode.
        /// </summary>
        public DutyControlModeType DutyControlMode
        {
            get
            {
                return _dutyControlMode;
            }

            set
            {
                _dutyControlMode = value;
            }
        }

        /// <summary>
        /// Power monitor reading (W).
        /// </summary>
        public float PowerMonitorReading
        {
            get
            {
                return _powerMonitorReading;
            }

            set
            {
                _powerMonitorReading = value;
            }
        }

        /// <summary>
        /// Flow reading (L/min).
        /// </summary>
        public float FlowReading
        {
            get
            {
                return _flowReading;
            }

            set
            {
                _flowReading = value;
            }
        }

        /// <summary>
        /// Humidity reading (%).
        /// </summary>
        public ushort HumidityReading
        {
            get
            {
                return _humidityReading;
            }

            set
            {
                _humidityReading = value;
            }
        }

        /// <summary>
        /// Ip address.
        /// </summary>
        public string IpAddress
        {
            get
            {
                return _ipAddress;
            }

            set
            {
                _ipAddress = value;
            }
        }

        /// <summary>
        /// Subnet mask.
        /// </summary>
        public string SubnetMask
        {
            get
            {
                return _subnetMask;
            }

            set
            {
                _subnetMask = value;
            }
        }

        /// <summary>
        /// Gateway.
        /// </summary>
        public string Gateway
        {
            get
            {
                return _gateway;
            }

            set
            {
                _gateway = value;
            }
        }
        #endregion

        #region Field
        private SoftFaults _currentSoftFaults;
        private BoardFaults _currentBoardFaults;
        private SystemStatus _currentSystemStatus;
        private SystemFaults _currentSystemFaults;
        private GeneralAlarms _currentGeneralAlarms;
        private TemperatureControlFaults _currentTemperatureControlFaults;
        private SystemState _currentSystemState;

        private bool _enableShutter;
        private bool _enableLdd;
        private float _setCurrent;
        private float _actualCurrent;
        private float _diodeVoltage;
        private float _maxCurrent;
        private float _lddHours;
        private int _prf;
        private SourcesType _prfSource;
        private SourcesType _gateSource;
        private SourcesType _pecSource;
        private bool _fpkEnable;
        private int _fpkRampTime;
        private int _fpkRampRate;
        private bool _lpkEnable;
        private int _lpkRampTime;
        private int _lpkRampRate;
        private float _shgTemperatureSetPoint;
        private float _thgTemperatureSetPoint;
        private float _ldTemperatureSetPoint;
        private float _shgActualTemperature;
        private float _thgActualTemperature;
        private float _ldActualTemperature;
        private bool _dutyControl;
        private float _dutyControlWidth;
        private float _pecLevel;
        private bool _burstStatus;
        private ushort _burstCount;
        private ushort _burstRate;
        private ushort _burstCycles;
        private BurstFiringModeType _burstFiringMode;
        private BurstTriggerSourceType _burstTriggerSource;
        private DutyControlModeType _dutyControlMode;
        private float _powerMonitorReading;
        private float _flowReading;
        private ushort _humidityReading;
        private string _ipAddress;
        private string _subnetMask;
        private string _gateway;
        #endregion

        #region Construct
        public PiLaserStatus()
        {
            _currentSoftFaults = new SoftFaults();
            _currentBoardFaults = new BoardFaults();
            _currentSystemStatus = new SystemStatus();
            _currentSystemFaults = new SystemFaults();
            _currentGeneralAlarms = new GeneralAlarms();
            _currentTemperatureControlFaults = new TemperatureControlFaults();
            _currentSystemState = new SystemState();

            IpAddress = "000.000.000.000";
            SubnetMask = "000.000.000.000";
            Gateway = "000.000.000.000";
        }
        #endregion

        #region Function
        /// <summary>
        /// Change soft fauls
        /// </summary>
        /// <param name="softFaults">Soft faults</param>
        public void ChangeSoftFaults(byte softFaults)
        {
            var bit = new BitArray(new byte[] { softFaults });

            _currentSoftFaults.HfSync = bit[0];
            _currentSoftFaults.LddInterlock = bit[1];
            _currentSoftFaults.ShutterInterlock = bit[2];
            _currentSoftFaults.LowExtFrequency = bit[3];
        }
        
        /// <summary>
        /// Change board faults
        /// </summary>
        /// <param name="boardFaults">Board faulse</param>
        public void ChangeBoardFaults(byte boardFaults)
        {
            var bit = new BitArray(new byte[] { boardFaults });

            _currentBoardFaults.Main = bit[0];
            _currentBoardFaults.Common = bit[1];
            _currentBoardFaults.Temperature = bit[2];
            _currentBoardFaults.Sensor = bit[3];
            _currentBoardFaults.PowerMonitor = bit[4];
            _currentBoardFaults.Pulse = bit[5];
            _currentBoardFaults.Ldd = bit[6];
            _currentBoardFaults.Motor = bit[7];
        }

        /// <summary>
        /// Change system status.
        /// </summary>
        /// <param name="systemStatus">System status</param>
        public void ChangeSystemStatus(byte systemStatus)
        {
            var bit = new BitArray(new byte[] { systemStatus });

            _currentSystemStatus.PowerOn = bit[0];
            _currentSystemStatus.ShutterEnabled= bit[1];
            _currentSystemStatus.KeySwitch = bit[2];
            _currentSystemStatus.LddOn = bit[3];
            _currentSystemStatus.QswOn = bit[4];
            _currentSystemStatus.ShutterInterlock = bit[5];
            _currentSystemStatus.LddInterlock = bit[6];
        }
        
        /// <summary>
        /// Change system faults
        /// </summary>
        /// <param name="systemFaults">System faults</param>
        public void ChangeSystemFaults(byte systemFaults)
        {
            var bit = new BitArray(new byte[] { systemFaults });

            _currentSystemFaults.Memory = bit[0];
            _currentSystemFaults.SdCard = bit[1];
            _currentSystemFaults.BoardCommunication = bit[2];
            _currentSystemFaults.BoardState = bit[3];
        }

        /// <summary>
        /// Change general alrams
        /// </summary>
        /// <param name="generalAlarms">General alarms</param>
        public void ChangeGeneralAlarms(byte generalAlarms)
        {
            var bit = new BitArray(new byte[] { generalAlarms });

            _currentGeneralAlarms.Ldd1 = bit[0];
            _currentGeneralAlarms.Ldd2 = bit[1];
            _currentGeneralAlarms.Qsw = bit[2];
            _currentGeneralAlarms.Flow = bit[3];
            _currentGeneralAlarms.Wet = bit[4];
            _currentGeneralAlarms.Humidity = bit[5];
            _currentGeneralAlarms.HfSync = bit[6];
        }

        /// <summary>
        /// Change temperature control faults
        /// </summary>
        /// <param name="temperatureControlFaults">Temperature control faults</param>
        public void ChangeTemperatureControlFaults(byte temperatureControlFaults)
        {
            var bit = new BitArray(new byte[] { temperatureControlFaults });

            _currentTemperatureControlFaults.TemperatureControlFault0 = bit[0];
            _currentTemperatureControlFaults.TemperatureControlFault1 = bit[1];
            _currentTemperatureControlFaults.TemperatureControlFault2 = bit[2];
            _currentTemperatureControlFaults.TemperatureControlFault3 = bit[3];
            _currentTemperatureControlFaults.TemperatureControlFault4 = bit[4];
            _currentTemperatureControlFaults.TemperatureControlFault5 = bit[5];
            _currentTemperatureControlFaults.TemperatureControlFault6 = bit[6];
            _currentTemperatureControlFaults.TemperatureControlFault7 = bit[7];
        }

        /// <summary>
        /// Change system state
        /// </summary>
        /// <param name="systemState">System state</param>
        public void ChangeSystemState(byte systemState)
        {
            var bit = new BitArray(new byte[] { systemState });

            _currentSystemState.SystemInitialization = bit[0];
            _currentSystemState.Setup = bit[1];
            _currentSystemState.Running = bit[2];
            _currentSystemState.Standby = bit[3];
            _currentSystemState.SoftFault = bit[4];
            _currentSystemState.HardFault = bit[5];
        }
        #endregion
    }
}