using System;

using System.Threading;
using System.IO.Ports;
using System.Windows.Forms;

using LFP_Manager.DataStructure;
using LFP_Manager.Function;
using LFP_Manager.Utils;
using DevExpress.XtraGauges.Core.Model;

namespace LFP_Manager.Threads
{
    #region DELEGATE
    public delegate void UartDataUpdate(object sender, ref DeviceSystemData aSystemData);
    public delegate void UartDataRecv(byte[] data);
    public delegate void UartDataPrint(object sender, string msg);
    #endregion

    class csUartThread
    {
        #region VARIABLES

        private readonly CommConfig Config;
        private DeviceSystemData SystemData;
        private Thread serialComm = null;
        private SerialPort sPort = null;
        private bool SerialPortThreadEnd = true;

        public int SystemId = 0;
        private bool UartPolling = false;
        private bool AutoUartTx = true;

        private int addr_ch = 0;
        private ushort RequestRegAddr = 0x0000;                 //Byul Init 0x0000
        private ushort RequestRegLen = 50;
        private bool rFlag = false;
        private int rFlag2 = 0;
        private int wFlag = 0;

        private ushort ReadRegAddr = 0x0000;                   //Byul Init 0x0000
        private ushort ReadRegLen = 0x0000;                   //Byul Init 0x0000

        private ushort WriteRegAddr = 0x0000;                   //Byul Init 0x0000
        private short WriteCoilRegData = 0;
        private byte[] WriteRegData;

        private TUartTxBuff uartTxBuff = null;

        public event UartDataUpdate OnUpdate = null;
        public event UartDataRecv OnDataRecv = null;
        public event UartDataPrint OnPrint = null;

        #endregion

        #region CONSTRUCTORS

        public csUartThread(int sId, CommConfig aConfig, ref DeviceSystemData aSystemData)
        {
            SystemId = sId;
            Config = aConfig;
            SystemData = aSystemData;

            uartTxBuff = new TUartTxBuff();

            serialComm = new Thread(uartCommThread);
        }

        public void disposeThread()
        {
            if (sPort != null)
            {
                if (sPort.IsOpen)
                {
                    sPort.Close();
                }
                sPort = null;
            }
            SerialPortThreadEnd = true;
            if (serialComm != null)
            {
                if (serialComm.IsAlive)
                {
                    serialComm.Abort();
                }
                serialComm = null;
            }
        }

        public bool Start(ref CommConfig aConfig, int sId, bool aPolling)
        {
            bool result = false;

            SystemId = sId;
            UartPolling = aPolling;

            if (Open(aConfig.UartPort, 115200))          //Byul Init 9600
            {
                SerialPortThreadEnd = false;
                serialComm.Start();
                result = true;
            }
            return result;
        }

        public void Stop()
        {
            SerialPortThreadEnd = true;
            Close();
        }

        #endregion

        #region COMMPORT CONTROLS

        private void sDataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            byte[] sRead = new byte[1024];
            int rLen = 0;

            try
            {
                rLen = ((SerialPort)sender).Read(sRead, 0, 1024);

                for (int i = 0; i < rLen; i++)
                {
                    PutBuff(sRead[i]);
                }
            }
            catch (Exception)
            {

            }
        }

        private void sErrorReceived(object sender, System.IO.Ports.SerialErrorReceivedEventArgs e)
        {
            //
            //csMakeDataFunction.SetData()
        }

        private void sPinChanged(object sender, System.IO.Ports.SerialPinChangedEventArgs e)
        {
            //
        }

        private bool Open(string cPort, int cBaudrate)
        {
            sPort = new SerialPort();
            sPort.PortName = cPort;
            sPort.BaudRate = cBaudrate;
            sPort.DataReceived += sDataReceived;
            sPort.ErrorReceived += sErrorReceived;
            sPort.PinChanged += sPinChanged;

            try
            {
                sPort.Open();
            }
            catch (Exception ex)
            {
                throw new Exception("Error Open - " + ex.Message);
            }

            return sPort.IsOpen;
        }

        private void Close()
        {
            if (sPort != null)
            {
                if (sPort.IsOpen)
                {
                    sPort.Close();
                }
                sPort = null;
            }
        }

        #endregion

        #region PUBLIC FUNCTION

        public void SetPolling(bool flag, int sId, ref DeviceSystemData aSystemData)
        {
            SystemId = sId;
            UartPolling = flag;
            SystemData = aSystemData;
            SystemData.mNo = SystemId;
        }

        public void SetAutoTx(bool autoTx)
        {
            AutoUartTx = autoTx;
        }

        public void SetWriteCoilReg(ushort WriteAddr, short WriteData)
        {
            wFlag = 2;
            WriteRegAddr = WriteAddr;
            WriteCoilRegData = WriteData;

            for (int i = 0; i < 500; i += 10)
            {
                Thread.Sleep(10);
                Application.DoEvents();
            }
        }

        public void SetWriteReg(ushort WriteAddr, byte[] WriteData, bool ReplyFlag, int type)
        {
            WriteRegAddr = WriteAddr;

            TUartTRxData uartTRxData = new TUartTRxData();
            uartTRxData.type = type;
            //uartTRxData.data = csSerialCommFunction.MakeWriteRegisterData((ushort)SystemId, WriteRegAddr, WriteData);
            uartTRxData.data = WriteData;
            uartTRxData.length = uartTRxData.data.Length;

            uartTxBuff?.PutBuff(uartTRxData);
        }
        public void SetReadReg(ushort ReadAddr, ushort ReadLen, bool ReplyFlag)
        {
            wFlag = 4;
            ReadRegAddr = ReadAddr;
            ReadRegLen = ReadLen;
        }

        public void SetParam(ushort WriteAddr, short[] WriteData)
        {
            wFlag = 1;

            WriteRegAddr = WriteAddr;

            TUartTRxData uartTRxData = new TUartTRxData();
            uartTRxData.type = wFlag;
            uartTRxData.data = csSerialCommFunction.MakeWriteRegisterData((ushort)SystemId, WriteRegAddr, WriteData);
            uartTRxData.length = uartTRxData.data.Length;

            uartTxBuff?.PutBuff(uartTRxData);
        }

        public void SendProcessFromApp(int sId, int mode, int index, int flag, ref DeviceParamData aParam, ref DeviceCalibration aCalib)
        {
            short[] data = null;

            switch (mode)
            {
                case csConstData.UART_PARAM_LIST.CELL_UNDER_VOLTAGE:         // Cell Under Volatge Parameter
                    data = new short[1];
                    data[0] = aParam.CellUnderVoltageWarning;   SetParam((ushort)(mode + 0), data);
                    data[0] = aParam.CellUnderVoltageTrip;      SetParam((ushort)(mode + 1), data);
                    data[0] = aParam.CellUnderVoltageRelease;   SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.CELL_OVER_VOLTAGE:         // Cell Over Volatge Parameter
                    data = new short[1];
                    data[0] = aParam.CellOverVoltageWarning; SetParam((ushort)(mode + 0), data);
                    data[0] = aParam.CellOverVoltageTrip; SetParam((ushort)(mode + 1), data);
                    data[0] = aParam.CellOverVoltageRelease; SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.PACK_UNDER_VOLTAGE:         // Pack Under Volatge Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.SysUnderVoltageWarning * 10); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.SysUnderVoltageTrip * 10); SetParam((ushort)(mode + 1), data);
                    data[0] = (short)(aParam.SysUnderVoltageRelease * 10); SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.PACK_OVER_VOLTAGE:         // Pack Over Volatge Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.SysOverVoltageWarning * 10); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.SysOverVoltageTrip * 10); SetParam((ushort)(mode + 1), data);
                    data[0] = (short)(aParam.SysOverVoltageRelease * 10); SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.CHG_LOW_TEMPERATURE:         // Charge Low Temperature Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.ChaLowTempWarning + 50); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.ChaLowTempTrip + 50); SetParam((ushort)(mode + 1), data);
                    data[0] = (short)(aParam.ChaLowTempRelease + 50); SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.CHG_HIGH_TEMPERATURE:         // Pack High Temperature Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.ChaHighTempWarning + 50); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.ChaHighTempTrip + 50); SetParam((ushort)(mode + 1), data);
                    data[0] = (short)(aParam.ChaHighTempRelease + 50); SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.DCH_LOW_TEMPERATURE:         // Charge Low Temperature Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.DchLowTempWarning + 50); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.DchLowTempTrip + 50); SetParam((ushort)(mode + 1), data);
                    data[0] = (short)(aParam.DchLowTempRelease + 50); SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.DCH_HIGH_TEMPERATURE:         // Pack High Temperature Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.DchHighTempWarning + 50); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.DchHighTempTrip + 50); SetParam((ushort)(mode + 1), data);
                    data[0] = (short)(aParam.DchHighTempRelease + 50); SetParam((ushort)(mode + 2), data);
                    break;
                case csConstData.UART_PARAM_LIST.CHG_OVER_CURRENT:         // Charge Over Current Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.ChaOverCurrentReleaseTime * 1); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.ChaOverCurrentTrip1 * 10); SetParam((ushort)(mode + 2), data);
                    data[0] = (short)(aParam.ChaOverCurrentTrip2 * 10); SetParam((ushort)(mode + 5), data);
                    break;
                case csConstData.UART_PARAM_LIST.DCH_OVER_CURRENT:         // Discharge Over Current Parameter
                    data = new short[1];
                    data[0] = (short)(aParam.DchOverCurrentReleaseTime * 1); SetParam((ushort)(mode + 0), data);
                    data[0] = (short)(aParam.DchOverCurrentTrip1 * 10); SetParam((ushort)(mode + 2), data);
                    data[0] = (short)(aParam.DchOverCurrentTrip2 * 10); SetParam((ushort)(mode + 5), data);
                    break;
                case csConstData.UART_PARAM_LIST.LOW_CAPACITY:
                    data = new short[1];
                    data[0] = aParam.LowSocWarning; SetParam((ushort)(mode + 0), data);
                    break;
                case csConstData.UART_PARAM_LIST.DEFAULT_PARAM:         // Default Parameter
                    int i = 0;

                    Forms.fmxWait WaitForm = new Forms.fmxWait();
                    WaitForm.StartPosition = FormStartPosition.CenterScreen;

                    try
                    {
                        //WaitForm.Show();
                        data = new short[1];

                        i = csConstData.UART_PARAM_LIST.CELL_UNDER_VOLTAGE;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Warn_Cell_UV; SetParam((ushort)(i + 0), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Cell_UV; SetParam((ushort)(i + 1), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Release_Cell_UV; SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.PACK_UNDER_VOLTAGE;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Warn_Pack_UV; SetParam((ushort)(i + 0), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Pack_UV; SetParam((ushort)(i + 1), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Release_Pack_UV; SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.CELL_OVER_VOLTAGE;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Warn_Cell_OV; SetParam((ushort)(i + 0), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Cell_OV; SetParam((ushort)(i + 1), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Release_Cell_OV; SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.PACK_OVER_VOLTAGE;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Warn_Pack_OV; SetParam((ushort)(i + 0), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Pack_OV; SetParam((ushort)(i + 1), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Release_Pack_OV; SetParam((ushort)(i + 2), data);

                        i = csConstData.UART_PARAM_LIST.CHG_OVER_CURRENT;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Times_Charge_OC; SetParam((ushort)(i - 2), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.ReleaseTime_Charge_OC; SetParam((ushort)(i + 0), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Charge_OC1; SetParam((ushort)(i + 2), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Charge_OC2; SetParam((ushort)(i + 5), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Delay_Charge_OC1; SetParam((ushort)(i + 8), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Delay_Charge_OC2; SetParam((ushort)(i + 9), data);

                        i = csConstData.UART_PARAM_LIST.DCH_OVER_CURRENT;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Times_Discharge_OC; SetParam((ushort)(i - 2), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.ReleaseTime_Discharge_OC; SetParam((ushort)(i + 0), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Discharge_OC1; SetParam((ushort)(i + 2), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Protect_Discharge_OC2; SetParam((ushort)(i + 5), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Delay_Discharge_OC1; SetParam((ushort)(i + 8), data);
                        data[0] = csConstData.UART_PARAM_DEFAULT.Delay_Discharge_OC2; SetParam((ushort)(i + 9), data);

                        i = csConstData.UART_PARAM_LIST.CHG_LOW_TEMPERATURE;
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Warn_Charge_UT + 50); SetParam((ushort)(i + 0), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Protect_Charge_UT + 50); SetParam((ushort)(i + 1), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Release_Charge_UT + 50); SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.CHG_HIGH_TEMPERATURE;
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Warn_Charge_OT + 50); SetParam((ushort)(i + 0), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Protect_Charge_OT + 50); SetParam((ushort)(i + 1), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Release_Charge_OT + 50); SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.DCH_LOW_TEMPERATURE;
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Warn_Discharge_UT + 50); SetParam((ushort)(i + 0), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Protect_Discharge_UT + 50); SetParam((ushort)(i + 1), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Release_Discharge_UT + 50); SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.DCH_HIGH_TEMPERATURE;
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Warn_Discharge_OT + 50); SetParam((ushort)(i + 0), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Protect_Discharge_OT + 50); SetParam((ushort)(i + 1), data);
                        data[0] = (short)(csConstData.UART_PARAM_DEFAULT.Release_Discharge_OT + 50); SetParam((ushort)(i + 2), data);

                        i = csConstData.UART_PARAM_LIST.LOW_CAPACITY;
                        data[0] = csConstData.UART_PARAM_DEFAULT.Warn_Low_Capacity + 0; SetParam((ushort)(i + 0), data);

                        i = csConstData.UART_PARAM_LIST.ENV_LOW_TEMPERATURE;
                        data[0] = 0; SetParam((ushort)(i + 0), data);
                        data[0] = 0; SetParam((ushort)(i + 1), data);
                        data[0] = 0; SetParam((ushort)(i + 2), data);
                        i = csConstData.UART_PARAM_LIST.ENV_HIGH_TEMPERATURE;
                        data[0] = 0; SetParam((ushort)(i + 0), data);
                        data[0] = 0; SetParam((ushort)(i + 1), data);
                        data[0] = 0; SetParam((ushort)(i + 2), data);
                    }
                    catch (Exception)
                    {

                    }
                    finally
                    {
                        //WaitForm?.Close();
                    }
                    break;
                case 15:         // Capcity change
                    data = new short[1];
                    i = csConstData.UART_PARAM_LIST.DESIGN_CAPACITY;
                    data[0] = (short)aCalib.CapCalib.DesignCapacity; SetParam((ushort)(i + 0), data);
                    i = csConstData.UART_PARAM_LIST.SOC_VALUE;
                    data[0] = (short)aCalib.CapCalib.SocValue; SetParam((ushort)(i + 0), data);
                    break;
                case 16:         // Charge Mode
                    data = new short[1];
                    i = csConstData.UART_CALIB_ADDR_LIST.CHAGE_MODE;
                    data[0] = (short)aCalib.ChaMode.Mode; SetParam((ushort)(i + 0), data);
                    data[0] = (short)aCalib.ChaMode.Value; SetParam((ushort)(i + 1), data);
                    break;
                case 17:         // BMS DateTime Set
                    data = new short[2];
                    i = csConstData.UART_CALIB_ADDR_LIST.BMS_DATETIME;
                    data[0] = (short)aCalib.BmsDateTime.sValue[0]; 
                    data[1] = (short)aCalib.BmsDateTime.sValue[1]; SetParam((ushort)(i + 0), data);
                    break;
                case 18:
                    data = new short[1];
                    i = csConstData.UART_CALIB_ADDR_LIST.ANTI_THEFT_GYRO;
                    data[0] = (short)aCalib.AntiTheft.GyroScope; SetParam((ushort)(i + 0), data);
                    break;
                case 19:    // Clear Protect
                    data = new short[1];
                    i = csConstData.UART_CALIB_ADDR_LIST.ANTI_THEFT_GYRO;
                    data[0] = (short)0; SetParam((ushort)(i + 0), data);
                    data[0] = (short)aCalib.AntiTheft.GyroScope; SetParam((ushort)(i + 0), data);
                    break;
                case 20:
                    data = new short[1];
                    i = csConstData.UART_CALIB_ADDR_LIST.ANTI_THEFT_COMM;
                    data[0] = (short)aCalib.AntiTheft.Comm; SetParam((ushort)(i + 0), data);
                    break;
                case 21:        // Cell Balancing Voltage
                    data = new short[1];
                    i = csConstData.UART_CALIB_ADDR_LIST.BAL_VOLT;
                    data[0] = (short)aCalib.BalCalib.Volt; SetParam((ushort)(i + 0), data);
                    break;
                case 22:        // Cell Balancing Diff
                    data = new short[1];
                    i = csConstData.UART_CALIB_ADDR_LIST.BAL_DIFF;
                    data[0] = (short)aCalib.BalCalib.Volt; SetParam((ushort)(i + 0), data);
                    break;
                default:
                    break;
            }
        }

        #endregion

        #region RX BUFFERING

        private const int BUFFER_SIZE = 512;

        private readonly byte[] rBuffer = new byte[BUFFER_SIZE];
        private int rBufStart = 0;
        private int rBufEnd = 0;

        private void PutBuff(byte c)
        {
            rBuffer[rBufStart++] = c;
            rBufStart %= BUFFER_SIZE;

            if (rBufStart == rBufEnd)
            {
                rBufEnd++;
                rBufEnd %= BUFFER_SIZE;
            }
        }

        private int GetBuff()
        {
            int result = 0;

            if (rBufStart != rBufEnd)
            {
                result = 0x0100 + rBuffer[rBufEnd++];
                rBufEnd %= BUFFER_SIZE;
            }
            return result;
        }

        private void FlushBuff()
        {
            rBufStart = rBufEnd = 0;
        }

        #endregion

        #region TX BUFFERING

        private byte[] MakeWriteRegData(ushort DevID, ushort WriteAddr, ushort WriteLen, ref ushort[] WriteData)
        {
            byte[] wData = null;

            if (WriteLen > 0)
            {

            }

            return wData;
        }

        private string MakeCheckSum(byte[] sData, int len)
        {
            string result = "";
            int checksum = 0;

            for (int i = 0; i < len; i++)
            {
                checksum += sData[i + 1];
            }

            checksum = ~checksum + 1;

            result = String.Format("{0:X2}{1:X2}", (byte)(checksum >> 8), (byte)checksum);

            return result;
        }
   
        private byte[] MakeTxDataVision(ref bool wData)
        {
            byte[] sData = null;

            rFlag2 = 0;

            if ((uartTxBuff != null) && (uartTxBuff.CheckBuff()))
            {
                TUartTRxData sBuff = uartTxBuff.GetBuff();
                if (sBuff != null)
                {
                    sData = sBuff.data;
                    wData = true;
                    rFlag = true;
                    rFlag2 = sBuff.type;
                }
            }
            else if (wFlag == 2)
            {
                sData = csSerialCommFunction.MakeWriteCoilData((ushort)SystemId, WriteRegAddr, WriteCoilRegData);
                if (wFlag != 0) wFlag = 0;
                rFlag = true;
            }
            else if (wFlag == 3)
            {
                sData = WriteRegData;
                if (wFlag != 0) wFlag = 0;
                rFlag = true;
            }
            else if (wFlag == 4)
            {
                sData = csSerialCommFunction.MakeReadRegisterData((ushort)SystemId, csSerialCommFunction.READ_HOLDING_REG, ReadRegAddr, ReadRegLen);
                if (wFlag != 0) wFlag = 0;
                rFlag = true;
            }
            else
            {
                if (UartPolling && AutoUartTx)
                {
                    ushort sCmd;
                    switch (addr_ch)
                    {
                        case 0:
                            addr_ch = 1;
                            RequestRegAddr = 0x0000;        //Byul Init 0x0000
                            RequestRegLen = 0x0040;
                            sCmd = csSerialCommFunction.READ_HOLDING_REG;
                            rFlag = true;
                            break;
                        case 1:
                            addr_ch = 2;
                            RequestRegAddr = 0x0040;
                            RequestRegLen = 0x0040;
                            sCmd = csSerialCommFunction.READ_HOLDING_REG;
                            rFlag = true;
                            break;
                        case 2:
                            addr_ch = 3;
                            RequestRegAddr = 0x0080;
                            RequestRegLen = 0x0020 + 7;
                            sCmd = csSerialCommFunction.READ_HOLDING_REG;
                            rFlag = true;
                            break;
                        case 3:
                            if (Config.ModuleQty > 1)
                            {
                                SystemId++;
                                if (SystemId > Config.ModuleQty)
                                {
                                    SystemId = 1;
                                }
                            }
                            addr_ch = 0;
                            sCmd = csSerialCommFunction.NO_CMD;
                            rFlag = false;
                            break;
                        default:
                            addr_ch = 0;
                            RequestRegAddr = 0x0000;        //Byul Init 0x0000
                            RequestRegLen = 100;
                            sCmd = csSerialCommFunction.READ_HOLDING_REG;
                            break;
                    }
                    if (sCmd == csSerialCommFunction.NO_CMD)
                    {
                        sData = null;
                    }
                    else
                    {
                        sData = csSerialCommFunction.MakeReadRegisterData((ushort)SystemId, sCmd, RequestRegAddr, RequestRegLen);
                    }
                }
            }
            return sData;
        }

        #endregion

        #region COMM THREAD

        private readonly byte[] ReadBuf = new byte[BUFFER_SIZE];
        ushort rPosition = 0;
        bool BuffStart = false;

        private void RecvPacketInit()
        {
            BuffStart = false;
            rPosition = 0;
        }

        private void uartCommThread()
        {
            int RecvTimeout = Config.RecvWaitTime;
            int getData = 0;
            byte cData = 0;
            int TimeOutCount = 0;

        StartSend:
            while (SerialPortThreadEnd == false)
            {
                if ((sPort == null) || (sPort.IsOpen == false)) continue;

                bool wMode = false;
                byte[] txData = MakeTxDataVision(ref wMode);
                if (txData != null)
                {
                    FlushBuff();
                    sPort.Write(txData, 0, txData.Length);
                    OnPrint?.Invoke(this, csLog.trx_data_print(txData, txData.Length, 0));
                }

                if (rFlag == true)
                {
                    RecvPacketInit();
                    DateTime rDateTime = DateTime.Now;

                    while (true)
                    {
                        DateTime nDateTime = rDateTime.AddMilliseconds(RecvTimeout);
                        if (nDateTime < DateTime.Now) break;

                        if (((getData = GetBuff()) & 0x0100) != 0x0000)
                        {
                            rDateTime = DateTime.Now;
                            cData = (byte)(getData & 0x00FF);
                            if (rPosition >= BUFFER_SIZE) RecvPacketInit();

                            if (BuffStart == false)
                            {
                                if ((cData == (byte)SystemId) || (cData == (byte)0x7F))
                                {
                                    rPosition = 0;
                                    ReadBuf[rPosition++] = cData;
                                    BuffStart = true;
                                }
                            }
                            else
                            {
                                ReadBuf[rPosition++] = cData;

                                switch (csSerialCommFunction.ModbusPacketFromSlaveCheck(ReadBuf, rPosition))
                                {
                                    case 0:         // Need more data
                                        break;
                                    case 1:         // Packet OK, no error
                                        OnPrint?.Invoke(this, csLog.trx_data_print(ReadBuf, rPosition, 1));

                                        TimeOutCount = 0;

                                        int mID = ReadBuf[0];
                                        if (mID > 0) mID--;

                                        SystemData.CommFail = false;
                                        SystemData.ShelfCommFail = false;

                                        if (rFlag2 == 0)
                                        { 
                                            short[] result_code = csSerialCommFunction.SerialRxProcess(ReadBuf, RequestRegAddr, rPosition, ref SystemData);

                                            OnUpdate?.Invoke(this, ref SystemData);
                                        }
                                        else
                                        {
                                            rFlag2 = 0;
                                            wMode = false;
                                            WriteRegAddr = 0;
                                            if (OnDataRecv != null)
                                            {
                                                byte[] adata = new byte[rPosition + 1];
                                                for (int j = 0; j < adata.Length; j++) { adata[j] = ReadBuf[j]; }
                                                OnDataRecv(adata);
                                            }
                                        }
                                        rFlag = false;
                                        Thread.Sleep(100);
                                        goto StartSend;
                                    case 2:         // Fw Update Packet OK
                                        OnPrint?.Invoke(this, csLog.trx_data_print(ReadBuf, rPosition, 1));

                                        TimeOutCount = 0;
                                        rFlag = false;
                                        if (OnDataRecv != null)
                                        {
                                            byte[] adata = new byte[rPosition + 1];
                                            for (int j = 0; j < adata.Length; j++)
                                            {
                                                adata[j] = ReadBuf[j];
                                            }
                                            OnDataRecv(adata);
                                        }
                                        goto StartSend;
                                    case -1:        // Packet error
                                        RecvPacketInit();
                                        Thread.Sleep(100);
                                        goto StartSend;
                                    default:
                                        break;
                                }
                            }
                        }
                        else
                        {
                            Thread.Sleep(1);
                        }
                    }

                    if (rPosition > 0)
                    {
                        Thread.Sleep(1);
                    }
                    else
                    {
                        WriteRegAddr = 0;
                        TimeOutCount++;
                        if (TimeOutCount >= 5)
                        {
                            TimeOutCount = 5;
                            //SystemData[0].CommFail = true;
                            if (SystemData.ShelfCommFail == false)
                            {
                                csUtils.DataInit(Config, ref SystemData);
                                SystemData.ShelfCommFail = true;
                            }
                        }
                        Thread.Sleep(100);
                    }
                    OnUpdate?.Invoke(this, ref SystemData);
                    Thread.Sleep(1);
                }
                else
                {
                    Thread.Sleep(100);
                }   /* if (rFlag == true) */
                rPosition = 0;
            }
        }

        #endregion
    }
}