using Aurora.Api;
using Aurora.Api.Devices;
using Hermes;
using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Documents;
using static AuroraTriggerBoard.Trigger;

namespace AuroraTriggerBoard.SJT
{
    partial class SJTTrigger : SerialConn, ITrigger
    {
        uint m_iTrigSetupTime_us;
        uint m_iTrigPulseWidth_us;
        uint m_iRtnWaitTime_us;

        byte Max_OutCh = 8;
        byte DebugMode = 1;
        uint m_iSendReTry_Num = 2;
        uint HW_Ver = 0;
        uint FW_Ver = 0;
        uint BUILDSTAMP = 0;
        uint IDENTIFY_FLAG = 0;

        public SJTTrigger(string deviceId, bool isSimul) : base(deviceId, isSimul)
        {

        }

        public int Connect(IConnConfig config)
        {
            if (Open(config as SerialConnConfig) != E1.OK)
            {
                return E2.NOT_CONNECTED;
            }

            m_iTrigSetupTime_us = 1;
            m_iTrigPulseWidth_us = 1;
            //m_iRtnWaitTime_us = 100000;
            m_iRtnWaitTime_us = 100;

            return E1.OK;
        }

        public int Disconnect()
        {
            return Close();
        }

        //        public int DisableTrigCorrectTable()
        //        {
        //            uint data = 0x1;
        //
        //        }

        public bool IsCommError()
        {
            return IsConnected();
        }

        public byte ToHex(byte Data)
        {
            if ((Data & 0x10) == 0)  // a~f, A~F
            {
                Data += 9;
            }
            Data &= 0x0F;
            return Data;
        }


        public byte h2c(ref byte[] hex)
        {
            return Convert.ToByte((Convert.ToInt32(ToHex(hex[0])) << 4) | Convert.ToInt32(ToHex(hex[1])));
        }

        public byte Hex2Ascii(byte hex)
        {
            if (hex <= 9)
            {
                return Convert.ToByte((Convert.ToInt32(hex) | 0x30));
            }
            else if ((hex >= 10) && (hex <= 15))
            {
                return Convert.ToByte((Convert.ToInt32(hex - 9) | 0x40));
            }
            else return 0;
        }

        public int TotalBit_add(ref byte[] charPt, byte char_num)
        {
            int sum = 0;
            for (int i = 0; i < char_num; i++)
            {
                sum += (charPt[i] & 0x01) + ((charPt[i] & 0x02) >> 1) + ((charPt[i] & 0x04) >> 2) + ((charPt[i] & 0x08) >> 3) +
                      ((charPt[i] & 0x10) >> 4) + ((charPt[i] & 0x20) >> 5) + ((charPt[i] & 0x40) >> 6) + ((charPt[i] & 0x80) >> 7);
            }

            return sum;
        }

        //ushort SJUartSingleSend(int addr, uint data, sbyte mode = 0)
        ushort SJUartSingleSend<T>(int addr, T data, sbyte mode = 0)
        {       // by SJ 170126
            ushort rtn = 0;
            if (0 == mode) rtn = SJUartAsSingleSend(addr, data);
            else if (1 == mode) rtn = SJUartRawSingleSend(addr, data);

            //if ((DebugMode >= 2) && (NULL != Connected_COM)) {
            //    //CStringA Tmp;
            //    //Tmp.Format("Single Send 32Bit : Addr 0x%x / RAW mode %d / Data 0x%x: rtn %x\r\n ", addr, mode, data, rtn);        Put_Log(Tmp, *Connected_COM);

            //    string temp;
            //    temp = formatA("Single Send 32Bit : Addr 0x%x / RAW mode %d / Data 0x%x: rtn %x\r\n ", addr, mode, data, rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode >= 2) && (IsConnected() == true)) Log.D(String.Format("Single Send 32Bit : Addr 0x{0:x} / RAW mode {1:d} / Data 0x{2:x}: rtn {3:x} ", addr, mode, data, rtn));
            return rtn;
        }

        //public ushort SJUartAsSingleSend(int addr, uint data)
        public ushort SJUartAsSingleSend<T>(int addr, T data)
        {               // by SJ 170126
            byte[] StartSignal = new byte[2];
            byte[] RegAddr = new byte[4];
            byte[] Data = new byte[8];      // 4 * data length

            byte[] recvPacket = new byte[3];
            byte err_retry_cnt = 0;
            ushort rtn;

            uint bit_sum = 0;
            int i = 0;
            //            m_comm.m_QueueRead.Clear();

            // Data Seq1 : StartSignal

            StartSignal[0] = 0x48;  // H
            StartSignal[1] = 0x4E;  // N
            bit_sum += Convert.ToUInt32(TotalBit_add(ref StartSignal, 2));

            // Data Seq2 : Option (skip)
            // Data Seq3 : Addr
            RegAddr[0] = Hex2Ascii(Convert.ToByte(addr & 0x000F));
            RegAddr[1] = Hex2Ascii(Convert.ToByte((addr & 0x00F0) >> 4));
            RegAddr[2] = Hex2Ascii(Convert.ToByte((addr & 0x0F00) >> 8));
            RegAddr[3] = Hex2Ascii(Convert.ToByte((addr & 0xF000) >> 12));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref RegAddr, 4));

            // Data Seq4 : DataSeq
            //Data[0] = Hex2Ascii(Convert.ToByte(data & 0x0000000F)); Data[1] = Hex2Ascii(Convert.ToByte((data & 0x000000F0) >> 4));
            //Data[2] = Hex2Ascii(Convert.ToByte((data & 0x00000F00) >> 8)); Data[3] = Hex2Ascii(Convert.ToByte((data & 0x0000F000) >> 12));
            //Data[4] = Hex2Ascii(Convert.ToByte((data & 0x000F0000) >> 16)); Data[5] = Hex2Ascii(Convert.ToByte((data & 0x00F00000) >> 20));
            //Data[6] = Hex2Ascii(Convert.ToByte((data & 0x0F000000) >> 24)); Data[7] = Hex2Ascii(Convert.ToByte((data & 0xF0000000) >> 28
            Data[0] = Hex2Ascii(Convert.ToByte((uint)(object)data & 0x0000000F));
            Data[1] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x000000F0) >> 4));
            Data[2] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x00000F00) >> 8));
            Data[3] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x0000F000) >> 12));
            Data[4] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x000F0000) >> 16));
            Data[5] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x00F00000) >> 20));
            Data[6] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x0F000000) >> 24));
            Data[7] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0xF0000000) >> 28));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref Data, 8));


            // Data Seq5 : EndSignal
            byte[] EndSignal = new byte[] { 0x59 };   // Y
            bit_sum += Convert.ToUInt32(TotalBit_add(ref EndSignal, 1));

            // Data Seq5 : Checksum
            // just bit_sum raw data
            //    CheckSum[0] = Hex2Ascii( (INT8U)(bit_sum & 0x0F) );
            //    CheckSum[1] = Hex2Ascii( (INT8U)(bit_sum & 0xF0) >> 4 );

            // Data Integration
            byte[] packet = new byte[2 + 4 + 8 + 1 + 1];
            packet[0] = StartSignal[0];
            packet[1] = StartSignal[1];
            packet[2] = RegAddr[0];
            packet[3] = RegAddr[1];
            packet[4] = RegAddr[2];
            packet[5] = RegAddr[3];

            packet[6] = Data[0];
            packet[7] = Data[1];
            packet[8] = Data[2];
            packet[9] = Data[3];
            packet[10] = Data[4];
            packet[11] = Data[5];
            packet[12] = Data[6];
            packet[13] = Data[7];

            packet[14] = EndSignal[0];
            //    packet[15] = CheckSum[0];    packet[16] = CheckSum[1];
            packet[15] = Convert.ToByte(bit_sum);

            /*
                    m_comm.WriteComm(&packet[0], 16);


                    for(i = 0 ; i < 3 ; i++){
                        while(!m_comm.m_QueueRead.GetByte(&recvPacket[i]));
                    }


                    if((recvPacket[0] == StartSignal[1]) & (recvPacket[1] == 0x4F) & (recvPacket[2] == 0x4B) )
                    {
                        rtn = true;
                    }
                    else {

                    }

                    free (packet);
                    return rtn;
            */
            uint RtnWait_Cnt;
            while (true)
            {
                Write(packet);

                RtnWait_Cnt = 0;
                Thread.Sleep(10);
                while (Read(recvPacket) <= 0)
                {
                    Thread.Sleep(10);
                    RtnWait_Cnt += 10;
                    if (RtnWait_Cnt > m_iRtnWaitTime_us)
                    {
                        Log.D(String.Format("SJUartAsSingleSend Receive Fail {0:d} > {1:d}", RtnWait_Cnt, m_iRtnWaitTime_us));
                        return ERR_NORESPONSE;
                    }
                };

                if ((recvPacket[0] == StartSignal[1]) && (recvPacket[1] == 0x4F) && (recvPacket[2] == 0x4B))    // 'N OK'
                {
                    //            rtn = (recvPacket[2] | (recvPacket[1] << 8) | (recvPacket[0] << 16));
                    rtn = OK_RETURN;
                    break;
                }
                else
                {
                    Log.D(String.Format("SJUartAsSingleSend Send Fail {0:d} > {1:d} : {2:x}, {3:x}, {4:x}", err_retry_cnt, m_iSendReTry_Num, recvPacket[0], recvPacket[1], recvPacket[2]));
                    if (err_retry_cnt >= m_iSendReTry_Num)
                    {
                        rtn = Convert.ToUInt16(ERR_RTN_NOT_OK | (Convert.ToInt32(recvPacket[2]) & 0xff));
                        break;
                    }
                    else
                    {
                        err_retry_cnt++;
                    }
                }
            }

            return rtn;

        }

        //ushort SJUartRawSingleSend(int addr, uint data)
        ushort SJUartRawSingleSend<T>(int addr, T data)
        {               // by SJ 170906
            byte[] StartSignal = new byte[2];
            byte[] RegAddr = new byte[4];
            //byte[] Data = new byte[4];      // 2 * data length
            Int32 DataLength = Marshal.SizeOf(data);
            byte[] Data = new byte[DataLength];

            byte[] recvPacket = new byte[3];
            byte err_retry_cnt = 0;
            ushort rtn;

            uint bit_sum = 0;
            int i = 0;
            //            m_comm.m_QueueRead.Clear();

            // Data Seq1 : StartSignal

            StartSignal[0] = 0x48;  // H
            StartSignal[1] = 0x4F;  // O
            bit_sum += Convert.ToUInt32(TotalBit_add(ref StartSignal, 2));

            // Data Seq2 : Option (skip)
            // Data Seq3 : Addr
            RegAddr[0] = Hex2Ascii(Convert.ToByte(addr & 0x000F));
            RegAddr[1] = Hex2Ascii(Convert.ToByte((addr & 0x00F0) >> 4));
            RegAddr[2] = Hex2Ascii(Convert.ToByte((addr & 0x0F00) >> 8));
            RegAddr[3] = Hex2Ascii(Convert.ToByte((addr & 0xF000) >> 12));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref RegAddr, 4));

            // Data Seq4 : DataSeq
            #region <HairPinTwister>
            //Data[0] = Hex2Ascii(Convert.ToByte((uint)(object)data & 0x000000FF));
            //Data[1] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x0000FF00) >> 8));
            //Data[2] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0x00FF0000) >> 16));
            //Data[3] = Hex2Ascii(Convert.ToByte(((uint)(object)data & 0xFF000000) >> 24));
            //bit_sum += Convert.ToUInt32(TotalBit_add(ref Data, (byte)Data.Length));
            #endregion
            Data[0] = Convert.ToByte((uint)(object)data & 0x000000FF);
            Data[1] = Convert.ToByte(((uint)(object)data & 0x0000FF00) >> 8);
            Data[2] = Convert.ToByte(((uint)(object)data & 0x00FF0000) >> 16);
            Data[3] = Convert.ToByte(((uint)(object)data & 0xFF000000) >> 24);
            if (DataLength > 4)
            {
                Data[4] = Convert.ToByte(((uint)(object)data & 0xFF00000000) >> 32); Data[5] = Convert.ToByte(((uint)(object)data & 0xFF0000000000) >> 40);
                Data[6] = Convert.ToByte(((uint)(object)data & 0xFF000000000000) >> 48); Data[7] = Convert.ToByte(((uint)(object)data & 0xFF00000000000000) >> 56);
            }
            bit_sum += Convert.ToUInt32(TotalBit_add(ref Data, (byte)DataLength));

            // Data Seq5 : EndSignal
            byte[] EndSignal = new byte[] { 0x59 };   // Y
            bit_sum += Convert.ToUInt32(TotalBit_add(ref EndSignal, 1));

            // Data Seq5 : Checksum
            // just bit_sum raw data
            //    CheckSum[0] = Hex2Ascii( (INT8U)(bit_sum & 0x0F) );
            //    CheckSum[1] = Hex2Ascii( (INT8U)(bit_sum & 0xF0) >> 4 );

            // Data Integration
            byte[] packet = new byte[2 + 4 + DataLength + 1 + 1];
            packet[0] = StartSignal[0]; packet[1] = StartSignal[1];
            packet[2] = RegAddr[0]; packet[3] = RegAddr[1]; packet[4] = RegAddr[2]; packet[5] = RegAddr[3];

            packet[6] = Data[0]; packet[7] = Data[1]; packet[8] = Data[2]; packet[9] = Data[3];
            if (DataLength > 4)
            {
                packet[10] = Data[4]; packet[11] = Data[5]; packet[12] = Data[6]; packet[13] = Data[7];
                packet[14] = EndSignal[0];
                //    packet[15] = CheckSum[0];    packet[16] = CheckSum[1];
                packet[15] = Convert.ToByte(bit_sum);
            }
            else
            {
                packet[10] = EndSignal[0];
                //    packet[15] = CheckSum[0];    packet[16] = CheckSum[1];
                packet[11] = Convert.ToByte(bit_sum);
            }
            /*
                    m_comm.WriteComm(&packet[0], 16);


                    for(i = 0 ; i < 3 ; i++){
                        while(!m_comm.m_QueueRead.GetByte(&recvPacket[i]));
                    }


                    if((recvPacket[0] == StartSignal[1]) & (recvPacket[1] == 0x4F) & (recvPacket[2] == 0x4B) )
                    {
                        rtn = true;
                    }
                    else {

                    }

                    free (packet);
                    return rtn;
            */
            uint RtnWait_Cnt;
            while (true)
            {
                Write(packet);

                RtnWait_Cnt = 0;
                Thread.Sleep(10);
                while (Read(recvPacket) <= 0)
                {
                    Thread.Sleep(10);
                    RtnWait_Cnt += 10;
                    if (RtnWait_Cnt > m_iRtnWaitTime_us)
                    {
                        Log.D(String.Format("SJUartRawSingleSend Receive Fail {0:d} > {1:d}", RtnWait_Cnt, m_iRtnWaitTime_us));
                        return ERR_NORESPONSE;
                    }
                };

                if ((recvPacket[0] == StartSignal[1]) && (recvPacket[1] == 0x4F) && (recvPacket[2] == 0x4B))    // 'N OK'
                {
                    //            rtn = (recvPacket[2] | (recvPacket[1] << 8) | (recvPacket[0] << 16));
                    rtn = OK_RETURN;
                    break;
                }
                else
                {
                    //Thread.Sleep(50);
                    Log.D(String.Format("SJUartRawSingleSend Send Fail {0:d} > {1:d} : {2:x}, {3:x}, {4:x}", err_retry_cnt, m_iSendReTry_Num, recvPacket[0], recvPacket[1], recvPacket[2]));
                    if (err_retry_cnt >= m_iSendReTry_Num)
                    {
                        rtn = Convert.ToUInt16(ERR_RTN_NOT_OK | (Convert.ToInt32(recvPacket[2]) & 0xff));
                        break;
                    }
                    else
                    {
                        err_retry_cnt++;
                    }
                }
            }

            return rtn;
        }

        //ushort SJUartRawBurstSend(int addr, ulong[] data, byte data_num, sbyte S_Ioption = 0)
        ushort SJUartRawBurstSend<T>(int addr, ref T[] data, byte data_num, sbyte S_Ioption = 0)
        {   // by SJ 170213
            byte[] StartSignal = new byte[2];
            byte[] Option = new byte[4];
            byte[] RegAddr = new byte[4];
            byte[] Data = new byte[8];

            byte Max_ByteUnit = 0, Cur_ByteUnit;
            //ulong[] SendData = data;
            ulong[] SendData = data as ulong[];
            byte[] recvPacket = new byte[3];
            byte err_retry_cnt = 0;
            uint ByteLength;
            ushort rtn;

            uint bit_sum = 0;
            int i = 0, j = 0;
            //            m_comm.m_QueueRead.Clear();

            if ((0 == data_num) || (255 < data_num)) return ERR_VAL_BURST_DATANUM;

            // Data Seq1 : StartSignal

            StartSignal[0] = 0x48;  // H
            StartSignal[1] = 0x51;  // P
            bit_sum += Convert.ToUInt32(TotalBit_add(ref StartSignal, 2));

            // before option check
            for (i = 0; i < data_num; i++)
            {
                if (SendData[i] < 0x100) Cur_ByteUnit = 1;
                else if (SendData[i] < 0x10000) Cur_ByteUnit = 2;
                else if (SendData[i] < 0x1000000) Cur_ByteUnit = 3;
                else if (SendData[i] < 0x100000000) Cur_ByteUnit = 4;
                else if (SendData[i] < 0x10000000000) Cur_ByteUnit = 5;
                else if (SendData[i] < 0x1000000000000) Cur_ByteUnit = 6;
                else if (SendData[i] < 0x100000000000000) Cur_ByteUnit = 7;
                else Cur_ByteUnit = 8;

                if (Max_ByteUnit < Cur_ByteUnit) Max_ByteUnit = Cur_ByteUnit;
            }

            ByteLength = 2 + 4 + 4 + (Convert.ToUInt32(Max_ByteUnit) * Convert.ToUInt32(data_num)) + 1 + 1;

            // Data Seq2 : Option
            if (0 == S_Ioption) Option[0] = 0x49;       //'I'
            else Option[0] = 0x53;      //'S'
            Option[1] = Hex2Ascii(Convert.ToByte(data_num & 0x0F));                // data_count LSB
            Option[2] = Hex2Ascii(Convert.ToByte((data_num & 0xF0) >> 4));         // data_count MSB
            Option[3] = Hex2Ascii(Convert.ToByte(Max_ByteUnit & 0x0F));

            bit_sum += Convert.ToUInt32(TotalBit_add(ref Option, 4));

            // Data Seq3 : Addr
            RegAddr[0] = Hex2Ascii(Convert.ToByte(addr & 0x000F));
            RegAddr[1] = Hex2Ascii(Convert.ToByte((addr & 0x00F0) >> 4));
            RegAddr[2] = Hex2Ascii(Convert.ToByte((addr & 0x0F00) >> 8));
            RegAddr[3] = Hex2Ascii(Convert.ToByte((addr & 0xF000) >> 12));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref RegAddr, 4));

            // Data Seq4 : DataSeq
            for (i = 0; i < data_num; i++)
            {
                Data[0] = Convert.ToByte(SendData[i] & 0x000000FF); Data[1] = Convert.ToByte((SendData[i] & 0x0000FF00) >> 8);
                Data[2] = Convert.ToByte((SendData[i] & 0x00FF0000) >> 16); Data[3] = Convert.ToByte((SendData[i] & 0xFF000000) >> 24);
                Data[4] = Convert.ToByte((SendData[i] & 0xFF00000000) >> 32); Data[5] = Convert.ToByte((SendData[i] & 0xFF0000000000) >> 40);
                Data[6] = Convert.ToByte((SendData[i] & 0xFF000000000000) >> 48); Data[7] = Convert.ToByte((SendData[i] & 0xFF00000000000000) >> 56);
                bit_sum += Convert.ToUInt32(TotalBit_add(ref Data, Max_ByteUnit));
            }

            // Data Seq5 : EndSignal
            byte[] EndSignal = new byte[] { 0x59 };   // Y
            bit_sum += Convert.ToUInt32(TotalBit_add(ref EndSignal, 1));

            // Data Seq5 : Checksum
            // just bit_sum raw data
            //    CheckSum[0] = Hex2Ascii( (INT8U)(bit_sum & 0x0F) );
            //    CheckSum[1] = Hex2Ascii( (INT8U)(bit_sum & 0xF0) >> 4 );

            // Data Integration
            byte[] packet = new byte[ByteLength];
            packet[0] = StartSignal[0]; packet[1] = StartSignal[1];
            packet[2] = Option[0]; packet[3] = Option[1]; packet[4] = Option[2]; packet[5] = Option[3];
            packet[6] = RegAddr[0]; packet[7] = RegAddr[1]; packet[8] = RegAddr[2]; packet[9] = RegAddr[3];

            for (i = 0; i < data_num; i++)
            {
                for (j = 0; j < Max_ByteUnit; j++)
                {
                    switch (j)
                    {
                        case 0: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte(SendData[i] & 0x000000FF); break;
                        case 1: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0x0000FF00) >> 8); break;
                        case 2: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0x00FF0000) >> 16); break;
                        case 3: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0xFF000000) >> 24); break;
                        case 4: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0xFF00000000) >> 32); break;
                        case 5: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0xFF0000000000) >> 40); break;
                        case 6: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0xFF000000000000) >> 48); break;
                        case 7: packet[10 + i * Max_ByteUnit + j] = Convert.ToByte((SendData[i] & 0xFF00000000000000) >> 56); break;
                    }
                }
            }
            packet[ByteLength - 2] = EndSignal[0];
            packet[ByteLength - 1] = Convert.ToByte(bit_sum & 0xFF);

            uint RtnWait_Cnt;
            while (true)
            {
                Write(packet);

                RtnWait_Cnt = 0;
                Thread.Sleep(10);
                while (Read(recvPacket) <= 0)
                {
                    Thread.Sleep(10);
                    RtnWait_Cnt += 10;
                    if (RtnWait_Cnt > m_iRtnWaitTime_us)
                    {
                        Log.D(String.Format("SJUartRawBurstSend Receive Fail {0:d} > {1:d}", RtnWait_Cnt, m_iRtnWaitTime_us));
                        return ERR_NORESPONSE;
                    }
                };

                if ((recvPacket[0] == StartSignal[1]) && (recvPacket[1] == 0x4F) && (recvPacket[2] == 0x4B))    // 'N OK'
                {
                    //            rtn = (recvPacket[2] | (recvPacket[1] << 8) | (recvPacket[0] << 16));
                    rtn = OK_RETURN;
                    break;
                }
                else
                {
                    Log.D(String.Format("SJUartRawBurstSend Send Fail {0:d} > {1:d} : {2:x}, {3:x}, {4:x}", err_retry_cnt, m_iSendReTry_Num, recvPacket[0], recvPacket[1], recvPacket[2]));
                    if (err_retry_cnt >= m_iSendReTry_Num)
                    {
                        rtn = Convert.ToUInt16(ERR_RTN_NOT_OK | (Convert.ToInt32(recvPacket[2]) & 0xff));
                        break;
                    }
                    else
                    {
                        err_retry_cnt++;
                    }
                }
            }

            return rtn;
        }

        //ushort SJUartAsBurstSend(int addr, ulong[] data, byte data_num, sbyte S_Ioption)
        ushort SJUartAsBurstSend<T>(int addr, ref T[] data, byte data_num, sbyte S_Ioption = 0)
        {   // by SJ 170213
            byte[] StartSignal = new byte[2];
            byte[] Option = new byte[4];
            byte[] RegAddr = new byte[4];
            byte[] Data = new byte[16];

            byte Max_ByteUnit = 0, Cur_ByteUnit;
            //ulong[] SendData = data;
            //T[] SendData = (T[])(object)data.Clone();
            ulong[] SendData = Array.ConvertAll(data, (obj) => Convert.ToUInt64(obj));
            byte[] recvPacket = new byte[3];
            byte err_retry_cnt = 0;
            uint ByteLength;
            ushort rtn;

            uint bit_sum = 0;
            int i = 0, j = 0;
            //            m_comm.m_QueueRead.Clear();

            if ((0 == data_num) || (255 < data_num)) return ERR_VAL_BURST_DATANUM;

            // Data Seq1 : StartSignal

            StartSignal[0] = 0x48;  // H
            StartSignal[1] = 0x50;  // P
            bit_sum += Convert.ToUInt32(TotalBit_add(ref StartSignal, 2));

            // before option check
            for (i = 0; i < data_num; i++)
            {
                if (SendData[i] < 0x10) Cur_ByteUnit = 1;
                else if (SendData[i] < 0x100) Cur_ByteUnit = 2;
                else if (SendData[i] < 0x1000) Cur_ByteUnit = 3;
                else if (SendData[i] < 0x10000) Cur_ByteUnit = 4;
                else if (SendData[i] < 0x100000) Cur_ByteUnit = 5;
                else if (SendData[i] < 0x1000000) Cur_ByteUnit = 6;
                else if (SendData[i] < 0x10000000) Cur_ByteUnit = 7;
                else if (SendData[i] < 0x100000000) Cur_ByteUnit = 8;
                else if (SendData[i] < 0x1000000000) Cur_ByteUnit = 9;
                else if (SendData[i] < 0x10000000000) Cur_ByteUnit = 10;
                else if (SendData[i] < 0x100000000000) Cur_ByteUnit = 11;
                else if (SendData[i] < 0x1000000000000) Cur_ByteUnit = 12;
                else if (SendData[i] < 0x10000000000000) Cur_ByteUnit = 13;
                else if (SendData[i] < 0x100000000000000) Cur_ByteUnit = 14;
                else if (SendData[i] < 0x1000000000000000) Cur_ByteUnit = 16;       //caused by HDL logic
                else Cur_ByteUnit = 16;

                if (Max_ByteUnit < Cur_ByteUnit) Max_ByteUnit = Cur_ByteUnit;
            }

            ByteLength = 2 + 4 + 4 + (Convert.ToUInt32(Max_ByteUnit) * Convert.ToUInt32(data_num)) + 1 + 1;

            // Data Seq2 : Option
            if (0 == S_Ioption) Option[0] = 0x49;       //'I'
            else Option[0] = 0x53;      //'S'
            Option[1] = Hex2Ascii(Convert.ToByte(data_num & 0x0F));                // data_count LSB
            Option[2] = Hex2Ascii(Convert.ToByte((data_num & 0xF0) >> 4));         // data_count MSB

            if (Max_ByteUnit == 16) Option[3] = Hex2Ascii(Convert.ToByte(0x0f & 0x0F));
            else Option[3] = Hex2Ascii(Convert.ToByte(Max_ByteUnit & 0x0F));

            bit_sum += Convert.ToUInt32(TotalBit_add(ref Option, 4));

            // Data Seq3 : Addr
            RegAddr[0] = Hex2Ascii(Convert.ToByte(addr & 0x000F));
            RegAddr[1] = Hex2Ascii(Convert.ToByte((addr & 0x00F0) >> 4));
            RegAddr[2] = Hex2Ascii(Convert.ToByte((addr & 0x0F00) >> 8));
            RegAddr[3] = Hex2Ascii(Convert.ToByte((addr & 0xF000) >> 12));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref RegAddr, 4));

            // Data Seq4 : DataSeq
            for (i = 0; i < data_num; i++)
            {
                Data[0] = Hex2Ascii(Convert.ToByte(SendData[i] & 0x0000000F)); Data[1] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x000000F0) >> 4));
                Data[2] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x00000F00) >> 8)); Data[3] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0000F000) >> 12));
                Data[4] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x000F0000) >> 16)); Data[5] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x00F00000) >> 20));
                Data[6] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0F000000) >> 24)); Data[7] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF0000000) >> 28));
                Data[8] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0F00000000) >> 32)); Data[9] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF000000000) >> 36));
                Data[10] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0F0000000000) >> 40)); Data[11] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF00000000000) >> 44));
                Data[12] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0F000000000000) >> 48)); Data[13] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF0000000000000) >> 52));
                Data[14] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0F00000000000000) >> 56)); Data[15] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF000000000000000) >> 60));
                bit_sum += Convert.ToUInt32(TotalBit_add(ref Data, Max_ByteUnit));
            }

            // Data Seq5 : EndSignal
            byte[] EndSignal = new byte[] { 0x59 };   // Y
            bit_sum += Convert.ToUInt32(TotalBit_add(ref EndSignal, 1));

            // Data Seq5 : Checksum
            // just bit_sum raw data
            //    CheckSum[0] = Hex2Ascii( (INT8U)(bit_sum & 0x0F) );
            //    CheckSum[1] = Hex2Ascii( (INT8U)(bit_sum & 0xF0) >> 4 );

            // Data Integration
            byte[] packet = new byte[ByteLength];
            packet[0] = StartSignal[0]; packet[1] = StartSignal[1];
            packet[2] = Option[0]; packet[3] = Option[1]; packet[4] = Option[2]; packet[5] = Option[3];
            packet[6] = RegAddr[0]; packet[7] = RegAddr[1]; packet[8] = RegAddr[2]; packet[9] = RegAddr[3];

            for (i = 0; i < data_num; i++)
            {
                for (j = 0; j < Max_ByteUnit; j++)
                {
                    switch (j)
                    {
                        case 0: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte(SendData[i] & 0x0000000F)); break;
                        case 1: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x000000F0) >> 4)); break;
                        case 2: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x00000F00) >> 8)); break;
                        case 3: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0000F000) >> 12)); break;
                        case 4: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x000F0000) >> 16)); break;
                        case 5: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x00F00000) >> 20)); break;
                        case 6: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0x0F000000) >> 24)); break;
                        case 7: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF0000000) >> 28)); break;
                        case 8: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF00000000) >> 32)); break;
                        case 9: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF000000000) >> 36)); break;
                        case 10: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF0000000000) >> 40)); break;
                        case 11: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF00000000000) >> 44)); break;
                        case 12: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF000000000000) >> 48)); break;
                        case 13: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF0000000000000) >> 52)); break;
                        case 14: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF00000000000000) >> 56)); break;
                        case 15: packet[10 + i * Max_ByteUnit + j] = Hex2Ascii(Convert.ToByte((SendData[i] & 0xF000000000000000) >> 60)); break;
                    }
                }
            }
            packet[ByteLength - 2] = EndSignal[0];
            packet[ByteLength - 1] = Convert.ToByte(bit_sum & 0xFF);

            uint RtnWait_Cnt;
            while (true)
            {
                Write(packet);

                RtnWait_Cnt = 0;
                Thread.Sleep(10);
                while (Read(recvPacket) <= 0)
                {
                    Thread.Sleep(10);
                    RtnWait_Cnt += 10;
                    if (RtnWait_Cnt > m_iRtnWaitTime_us)
                    {
                        Log.D(String.Format("SJUartAsBurstSend Receive Fail {0:d} > {1:d}", RtnWait_Cnt, m_iRtnWaitTime_us));
                        return ERR_NORESPONSE;
                    }
                };

                if ((recvPacket[0] == StartSignal[1]) && (recvPacket[1] == 0x4F) && (recvPacket[2] == 0x4B))    // 'N OK'
                {
                    //            rtn = (recvPacket[2] | (recvPacket[1] << 8) | (recvPacket[0] << 16));
                    rtn = OK_RETURN;
                    break;
                }
                else
                {
                    Log.D(String.Format("SJUartAsBurstSend Send Fail {0:d} > {1:d} : {2:x}, {3:x}, {4:x}", err_retry_cnt, m_iSendReTry_Num, recvPacket[0], recvPacket[1], recvPacket[2]));
                    if (err_retry_cnt >= m_iSendReTry_Num)
                    {
                        rtn = Convert.ToUInt16(ERR_RTN_NOT_OK | (Convert.ToInt32(recvPacket[2]) & 0xff));
                        break;
                    }
                    else
                    {
                        err_retry_cnt++;
                    }
                }
            }

            return rtn;

        }

        //ushort SJUartBurstSend(int addr, ulong[] data, byte data_num, sbyte mode, sbyte S_Ioption)
        ushort SJUartBurstSend<T>(int addr, ref T[] data, byte data_num, sbyte mode, sbyte S_Ioption = 0)
        {   // by SJ 170213
            ushort rtn = 0;
            if (0 == mode) rtn = SJUartAsBurstSend(addr, ref data, data_num, S_Ioption);
            else if (1 == mode) rtn = SJUartRawBurstSend(addr, ref data, data_num, S_Ioption);

            //            if ((DebugMode >= 2) && (NULL != Connected_COM))
            //            {
            //                //        CStringA Tmp;
            //                //        Tmp.Format("Burst Send 64Bit : Addr 0x%x ~ %x  /  DataNum %d  /  RAW mode %d  /  SI_option %d  : rtn %x", addr, addr+data_num, data_num, mode, S_Ioption, rtn);
            //                //        Put_DataLog(Tmp, (__int64*)data, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);

            //               string temp;
            //               temp = formatA("Burst Send 64Bit : Addr 0x%x ~%x / DataNum %d / RAW mode %d / SI_option %d  : rtn %x", addr, addr + data_num, data_num, mode, S_Ioption, rtn);
            //               Put_DataLog(temp, (__int64*)data, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
            //           }

            return rtn;
        }
        //ushort SJUartRawSingleRecv(int addr, out ulong data)
        ushort SJUartRawSingleRecv<T>(int addr, ref T data)
        {               // by SJ 170906
            byte[] StartSignal = new byte[2];
            byte[] RegAddr = new byte[4];
            byte[] EndSignal = new byte[1];

            byte[] recvPacket = new byte[20];
            byte err_retry_cnt = 0;
            ushort rtn;

            uint Rbit_sum = 0;
            ushort Rtn_ByteLength;
            ushort Rtn_UnitByte;
            ulong Rtn_Data = 0;

            Rtn_UnitByte = 8;
            Rtn_ByteLength = Convert.ToUInt16(Rtn_UnitByte * 1 + 1 + 3);    // data + checksum + 3 rtn byte;

            uint bit_sum = 0;
            int i = 0;

            // Data Seq1 : StartSignal

            StartSignal[0] = 0x48;  // H
            StartSignal[1] = 0x53;  // S
            bit_sum += Convert.ToUInt32(TotalBit_add(ref StartSignal, 2));

            // Data Seq2 : Option (skip)
            // Data Seq3 : Addr
            RegAddr[0] = Hex2Ascii(Convert.ToByte(addr & 0x000F));
            RegAddr[1] = Hex2Ascii(Convert.ToByte((addr & 0x00F0) >> 4));
            RegAddr[2] = Hex2Ascii(Convert.ToByte((addr & 0x0F00) >> 8));
            RegAddr[3] = Hex2Ascii(Convert.ToByte((addr & 0xF000) >> 12));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref RegAddr, 4));

            // Data Seq4 : DataSeq
            // Data Seq5 : EndSignal
            EndSignal[0] = 0x59;   // Y
            bit_sum += Convert.ToUInt32(TotalBit_add(ref EndSignal, 1));

            // Data Seq5 : Checksum
            // just 'bit_sum' raw data

            // Data Integration
            byte[] packet = new byte[2 + 4 + 1 + 1];
            packet[0] = StartSignal[0]; packet[1] = StartSignal[1];
            packet[2] = RegAddr[0]; packet[3] = RegAddr[1]; packet[4] = RegAddr[2]; packet[5] = RegAddr[3];

            packet[6] = EndSignal[0];
            packet[7] = Convert.ToByte(bit_sum);

            //    m_comm.WriteComm(&packet[0], 8); // temporal
            uint RtnWait_Cnt;
            while (true)
            {
                Write(packet);

                Rbit_sum = 0;       // recv checksum initial

                RtnWait_Cnt = 0;
                Thread.Sleep(10);
                while (Read(recvPacket) <= 0) // <HairPinTwister> while (ReadMessage(recvPacket, Rtn_ByteLength, 200)< Rtn_ByteLength) {
                {
                    Thread.Sleep(10);
                    RtnWait_Cnt += 10;
                    if (RtnWait_Cnt > m_iRtnWaitTime_us)
                    {
                        Log.D(String.Format("SJUartRawSingleRecv Receive Fail {0:d} > {1:d}", RtnWait_Cnt, m_iRtnWaitTime_us));
                        return ERR_NORESPONSE;
                    }
                };

                if ((recvPacket[3] == StartSignal[1]) && ((recvPacket[4] == 0x54) | (recvPacket[5] == 0x58) | (recvPacket[2] == 0x53) | (recvPacket[2] == 0x57)))
                {
                    Log.D(String.Format("SJUartRawSingleRecv Receive Fail {0:x}, {1:x}, {2:x}, {3:x}", recvPacket[3], recvPacket[4], recvPacket[5], recvPacket[2]));
                    return Convert.ToUInt16((ERR_RTN_NOT_OK | (recvPacket[2] & 0xff)));
                }
                for (i = 0; i < Rtn_ByteLength - 4; i++)
                {
                    byte[] temppacket = { recvPacket[i] };
                    Rbit_sum += Convert.ToUInt16(TotalBit_add(ref temppacket, 1));
                }

                if ((recvPacket[Rtn_ByteLength - 3] == StartSignal[1]) && (recvPacket[Rtn_ByteLength - 2] == 0x4F) && (recvPacket[Rtn_ByteLength - 1] == 0x4B) && ((Rbit_sum & 0xff) == recvPacket[Rtn_ByteLength - 4]))    // 'T OK'
                {
                    //            rtn = (recvPacket[2] | (recvPacket[1] << 8) | (recvPacket[0] << 16));
                    for (i = 0; i < Rtn_UnitByte; i++)
                        Rtn_Data |= (Convert.ToUInt64(recvPacket[i]) << (i * 8));
                    //data = Rtn_Data;
                    data = (T)Convert.ChangeType(Rtn_Data, typeof(T));
                    rtn = OK_RETURN;
                    break;
                }
                else
                {
                    Log.D(String.Format("SJUartRawSingleRecv Receive Fail {0:d} > {1:d} : {2:x}, {3:x}, {4:x}, {5:x}", err_retry_cnt, m_iSendReTry_Num, recvPacket[Rtn_ByteLength - 3], recvPacket[Rtn_ByteLength - 2], recvPacket[Rtn_ByteLength - 1], recvPacket[Rtn_ByteLength - 4]));
                    if (err_retry_cnt == m_iSendReTry_Num)
                    {
                        if ((Rbit_sum & 0xff) != recvPacket[Rtn_ByteLength - 4])
                        {
                            rtn = Convert.ToUInt16(ERR_RTN_CHECKSUM | (recvPacket[Rtn_ByteLength - 4] & 0xff));
                        }
                        else
                        {
                            rtn = Convert.ToUInt16(ERR_RTN_NOT_OK | (recvPacket[Rtn_ByteLength - 1] & 0xff));
                        }
                        break;
                    }
                    else
                    {
                        err_retry_cnt++;
                    }
                }
            }

            return rtn;
        }
        //ushort SJUartAsSingleRecv(int addr, ref ulong data)
        ushort SJUartAsSingleRecv<T>(int addr, ref T data)
        {               // by SJ 170210
                        // Recv only raw mode 170905
            return ERR_NOT_DEVELOPED_YET;
        }

        //ushort SJUartSingleRecv(int addr, out ulong data, sbyte mode = 1)
        ushort SJUartSingleRecv<T>(int addr, ref T data, sbyte mode = 1)
        {       // by SJ 170906
            ushort rtn = 0;
            if (mode == 0) rtn = SJUartAsSingleRecv(addr, ref data);
            else rtn = SJUartRawSingleRecv(addr, ref data);

            //if ((DebugMode >= 2) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("Single Recv 64Bit : Addr 0x%x / RAW mode %d / Data 0x%I64x: rtn %x\r\n ", addr, mode, *data, rtn);        Put_Log(Tmp, *Connected_COM);

            //    string temp;
            //    temp = formatA("Single Recv 64Bit : Addr 0x%x / RAW mode %d / Data 0x%I64x: rtn %x\r\n ", addr, mode, *data, rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode >= 2) && (IsConnected() == true)) Log.D(String.Format("Single Recv 64Bit : Addr 0x{0:x} / RAW mode {1:d} / Data 0x{2:x}: rtn {3:x} ", addr, mode, data, rtn));

            return rtn;
        }

        //ushort SJUartRawBurstRecv(int addr, ulong[] data, byte data_num, sbyte S_Ioption = 0)
        ushort SJUartRawBurstRecv<T>(int addr, ref T[] data, byte data_num, sbyte S_Ioption = 0)
        {   // by SJ 170907
            byte[] StartSignal = new byte[2];
            byte[] Option = new byte[4];
            byte[] RegAddr = new byte[4];
            byte[] Data = new byte[8];      // 4 * data length

            byte Max_ByteUnit = 0;
            byte[] recvPacket = new byte[2050];
            byte err_retry_cnt = 0;
            uint ByteLength;
            ushort rtn;

            uint Rbit_sum = 0;
            ushort Rtn_ByteLength;
            ushort Rtn_UnitByte;
            //    INT32U    Rtn_Data = 0;
            ulong Rtn_Data = 0;

            Rtn_UnitByte = 8;
            Rtn_ByteLength = Convert.ToUInt16(Rtn_UnitByte * data_num + 1 + 3);    // data*read_cnt + checksum + 3 rtn byte;

            uint bit_sum = 0;
            int i = 0, j = 0;

            if ((0 == data_num) || (255 < data_num)) return ERR_VAL_BURST_DATANUM;
            //            m_comm.m_QueueRead.Clear();

            // Data Seq1 : StartSignal

            StartSignal[0] = 0x48;  // H
            StartSignal[1] = 0x52;  // N
            bit_sum += Convert.ToUInt32(TotalBit_add(ref StartSignal, 2));

            ByteLength = 2 + 4 + 4 + 1 + 1;

            // Data Seq2 : Option
            if (0 == S_Ioption) Option[0] = 0x49;       //'I'
            else Option[0] = 0x53;      //'S'
            Option[1] = Hex2Ascii(Convert.ToByte(data_num & 0x0F));
            Option[2] = Hex2Ascii(Convert.ToByte((data_num & 0xF0) >> 4));
            Option[3] = Hex2Ascii(Convert.ToByte(8 & 0x0F));   // Raw type 32bit

            bit_sum += Convert.ToUInt32(TotalBit_add(ref Option, 4));

            // Data Seq3 : Addr
            RegAddr[0] = Hex2Ascii(Convert.ToByte(addr & 0x000F));
            RegAddr[1] = Hex2Ascii(Convert.ToByte((addr & 0x00F0) >> 4));
            RegAddr[2] = Hex2Ascii(Convert.ToByte((addr & 0x0F00) >> 8));
            RegAddr[3] = Hex2Ascii(Convert.ToByte((addr & 0xF000) >> 12));
            bit_sum += Convert.ToUInt32(TotalBit_add(ref RegAddr, 4));

            // Data Seq4 : DataSeq

            // Data Seq5 : EndSignal
            byte[] EndSignal = new byte[] { 0x59 };   // Y
            bit_sum += Convert.ToUInt32(TotalBit_add(ref EndSignal, 1));

            // Data Seq5 : Checksum
            // just bit_sum raw data
            //    CheckSum[0] = Hex2Ascii( (INT8U)(bit_sum & 0x0F) );
            //    CheckSum[1] = Hex2Ascii( (INT8U)(bit_sum & 0xF0) >> 4 );

            // Data Integration
            byte[] packet = new byte[ByteLength];
            packet[0] = StartSignal[0]; packet[1] = StartSignal[1];
            packet[2] = Option[0]; packet[3] = Option[1]; packet[4] = Option[2]; packet[5] = Option[3];
            packet[6] = RegAddr[0]; packet[7] = RegAddr[1]; packet[8] = RegAddr[2]; packet[9] = RegAddr[3];

            packet[ByteLength - 2] = EndSignal[0];
            packet[ByteLength - 1] = Convert.ToByte(bit_sum & 0xFF);

            uint RtnWait_Cnt;
            while (true)
            {
                Write(packet, Convert.ToInt32(ByteLength));

                Rbit_sum = 0;       // recv checksum initial

                RtnWait_Cnt = 0;
                Thread.Sleep(10);
                while (Read(recvPacket) <= 0) // <HairPinTwister> while (ReadMessage(recvPacket, Rtn_ByteLength, 200)< Rtn_ByteLength) {
                {
                    Thread.Sleep(10);
                    RtnWait_Cnt += 10;
                    if (RtnWait_Cnt > m_iRtnWaitTime_us)
                    {
                        Log.D(String.Format("SJUartRawSingleRecv Receive Fail {0:d} > {1:d}", RtnWait_Cnt, m_iRtnWaitTime_us));
                        return ERR_NORESPONSE;
                    }
                };

                if ((recvPacket[3] == StartSignal[1]) && ((recvPacket[4] == 0x54) | (recvPacket[5] == 0x58) | (recvPacket[2] == 0x53) | (recvPacket[2] == 0x57)))
                {
                    Log.D(String.Format("SJUartRawBurstRecv Receive Fail {0:x}, {1:x}, {2:x}, {3:x}", recvPacket[3], recvPacket[4], recvPacket[5], recvPacket[2]));
                    return Convert.ToUInt16((ERR_RTN_NOT_OK | (recvPacket[2] & 0xff)));
                }
                for (i = 0; i < Rtn_ByteLength - 4; i++)
                {
                    byte[] temppacket = { recvPacket[i] };
                    Rbit_sum += Convert.ToUInt16(TotalBit_add(ref temppacket, 1));
                }

                if ((recvPacket[Rtn_ByteLength - 3] == StartSignal[1]) && (recvPacket[Rtn_ByteLength - 2] == 0x4F) && (recvPacket[Rtn_ByteLength - 1] == 0x4B) && ((Rbit_sum & 0xff) == recvPacket[Rtn_ByteLength - 4]))    // 'T OK'
                {
                    for (j = 0; j < data_num; j++)
                    {
                        for (i = 0; i < Rtn_UnitByte; i++)
                        {
                            //                    Rtn_Data |= (recvPacket[(j * 4) + i] << (i * 8));
                            Rtn_Data |= (Convert.ToUInt64(recvPacket[(j * 8) + i]) << (i * 8));
                        }
                        //data[j] = Rtn_Data;
                        data[j] = (T)Convert.ChangeType(Rtn_Data, typeof(T));
                        Rtn_Data = 0;
                    }
                    rtn = OK_RETURN;
                    break;
                }
                else
                {
                    Log.D(String.Format("SJUartRawBurstRecv Receive Fail {0:d} > {1:d} : {2:x}, {3:x}, {4:x}, {5:x}", err_retry_cnt, m_iSendReTry_Num, recvPacket[Rtn_ByteLength - 3], recvPacket[Rtn_ByteLength - 2], recvPacket[Rtn_ByteLength - 1], recvPacket[Rtn_ByteLength - 4]));
                    if (err_retry_cnt == m_iSendReTry_Num)
                    {
                        if ((Rbit_sum & 0xff) != recvPacket[Rtn_ByteLength - 4])
                            rtn = Convert.ToUInt16((ERR_RTN_CHECKSUM | (recvPacket[Rtn_ByteLength - 4] & 0xff)));
                        else
                            rtn = Convert.ToUInt16((ERR_RTN_NOT_OK | (recvPacket[Rtn_ByteLength - 1] & 0xff)));
                        break;
                    }
                    else
                    {
                        err_retry_cnt++;
                    }
                }
            }

            return rtn;
        }

        //ushort SJUartAsBurstRecv(int addr, ulong[] data, byte data_num, sbyte S_Ioption)
        ushort SJUartAsBurstRecv<T>(int addr, ref T[] data, byte data_num, sbyte S_Ioption = 0)
        {       // by SJ 170307
            return ERR_NOT_DEVELOPED_YET;
        }

        //ushort SJUartBurstRecv(int addr, ulong[] data, byte data_num, sbyte mode = 1, sbyte S_Ioption = 0)
        ushort SJUartBurstRecv<T>(int addr, ref T[] data, byte data_num, sbyte mode = 1, sbyte S_Ioption = 0)
        {   // by SJ 170906
            ushort rtn = 0;
            if (mode == 0) rtn = SJUartAsBurstRecv(addr, ref data, data_num, S_Ioption);
            else rtn = SJUartRawBurstRecv(addr, ref data, data_num, S_Ioption);

            //            if ((DebugMode >= 2) && (null != Connected_COM))
            //            {
            //        CStringA Tmp;
            //        Tmp.Format("Burst Recv 64Bit : Addr 0x%x ~ %x  /  DataNum %d  /  RAW mode %d  /  SI_option %d  : rtn %x", addr, addr + data_num, data_num, mode, S_Ioption, rtn);
            //        Put_DataLog(Tmp, (__int64*)data, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);

            //                string temp;
            //                temp = formatA("Burst Recv 64Bit : Addr 0x%x ~ %x  /  DataNum %d  /  RAW mode %d  /  SI_option %d  : rtn %x", addr, addr + data_num, data_num, mode, S_Ioption, rtn);
            //                Put_DataLog(temp, (__int64*)data, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
            //            }
            return rtn;
        }

        public short GetSJTVersion(out string HwVer, out string tcstr)
        {

            ushort rtn = 0;
            ulong[] data = new ulong[2];
            char[] tmp_hwver = new char[16];

            //rtn = SJUartBurstRecv(SJT_HW_FW_VER, data, 2);
            rtn = SJUartBurstRecv<ulong>(SJT_HW_FW_VER, ref data, 2);

            if (0 == rtn)
            {
                //        HW_Ver = data[0];
                //        BUILDSTAMP = data[1] & 0xffffffff;

                string str = "";

                str += (char)((data[0] >> 0) & 0x0ff);
                str += (char)((data[0] >> 8) & 0x0ff);
                str += (char)((data[0] >> 16) & 0x0ff);
                str += (char)((data[0] >> 24) & 0x0ff);
                str += (char)((data[0] >> 32) & 0x0ff);
                str += (char)((data[0] >> 40) & 0x0ff);
                str += (char)((data[0] >> 48) & 0x0ff);
                str += (char)((data[0] >> 56) & 0x0ff);
                //str = string.Join(str, (char)((data[0] >> 0) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 8) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 16) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 24) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 32) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 40) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 48) & 0x0ff));
                //str = string.Join(str, (char)((data[0] >> 56) & 0x0ff));

                HwVer = str;

                /*        *HwVer = (char)((data[0] >> 0) & 0x0ff);    tmp_hwver[0] = *HwVer++;
                        *HwVer = (char)((data[0] >> 8) & 0x0ff);    tmp_hwver[1] = *HwVer++;
                        *HwVer = (char)((data[0] >> 16) & 0x0ff);    tmp_hwver[2] = *HwVer++;
                        *HwVer = (char)((data[0] >> 24) & 0x0ff);    tmp_hwver[3] = *HwVer++;
                        *HwVer = (char)((data[0] >> 32) & 0x0ff);    tmp_hwver[4] = *HwVer++;
                        *HwVer = (char)((data[0] >> 40) & 0x0ff);    tmp_hwver[5] = *HwVer++;
                        *HwVer = (char)((data[0] >> 48) & 0x0ff);    tmp_hwver[6] = *HwVer++;
                        *HwVer = (char)((data[0] >> 56) & 0x0ff);    tmp_hwver[7] = *HwVer++;
                        *HwVer = 0;                                    tmp_hwver[8] = *HwVer;*/


                TIMECNT tc;
                IDENTIFY_FLAG = Convert.ToUInt32(((data[1] & 0xffffffff00000000) >> 32));
                tc.day = Convert.ToSByte(((data[1] & 0xf8000000) >> 27) & 0xff);
                tc.month = Convert.ToSByte(((data[1] & 0x07800000) >> 23) & 0xff);
                tc.year = Convert.ToSByte(((data[1] & 0x007e0000) >> 17) & 0xff);
                tc.hour = Convert.ToSByte(((data[1] & 0x0001f000) >> 12) & 0xff);
                tc.minute = Convert.ToSByte(((data[1] & 0x00000fc0) >> 6) & 0xff);
                tc.seconds = Convert.ToSByte((data[1] & 0x0000003f) & 0xff);
                tcstr = string.Format("{0:d2}{1:d2}{2:d2}_{3:d2}{4:d2}", tc.year, tc.month, tc.day, tc.hour, tc.minute);

                if (IDENTIFY_FLAG == 0x1a3c5e7f)
                {
                    if ((DebugMode != 0) && (IsConnected() == true)) Log.D("HW_Ver : " + str + "BUILDSTAMP : " + tcstr);
                    return Convert.ToInt16(rtn);
                }
                else
                {
                    return 1;
                }

            }
            else
            {
                HwVer = "";
                tcstr = "";
                return -1;
            }

        }

        public ushort GetSJT_DLL_Ver(ref char[] DllVer)
        {
            string str;
#if DEBUG
#if WIN64
            str = "_64D";
#else
            str = "_86D";
#endif
#else //#ifdef _DEBUG --> Release
#if WIN64
            str = "_64R";
#else
            str = "_86R";
#endif
#endif
            str = DLL_TIME + str;
            DllVer = str.ToCharArray();

            if ((DebugMode != 0) && (IsConnected() == true)) Log.D("SJT_SDK Get Dll Version : " + str);
            return 1;
        }
        public ushort SetTrigTimerSeq(uint timerfreq_100ns, sbyte mode = 0)
        {
            ushort rtn = 0;
            uint[] RcvTmpt = new uint[3];
            uint GenMode, OutMode, data_num;
            ulong[] SendData = new ulong[5] { 0, 0, 0, 0, 0 };

            // FPGA Calc condition check Start//

            //genmode outmode check
            //support check
            //        rtn = SJUartRawSingleRecv(SJT_TRIG_GEN_OUT_MODE, &Check_Cur_Mode);
            rtn = SJUartRawBurstRecv<uint>(SJT_TRIG_GEN_OUT_MODE, ref RcvTmpt, 2);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

            GenMode = RcvTmpt[0] & 0xf; OutMode = (RcvTmpt[0] >> 16) & 0x7f;
            RcvTmpt[1] = RcvTmpt[1] & 0xffff;
            if (((0 == GenMode) || (3 == GenMode)) && ((2 == OutMode) || (3 == OutMode)) && (1912 == RcvTmpt[1]))
            {
                // FPGA CALC Code
                SendData[0] = 1;        //FCalc_Mode_Set
                SendData[1] = 1;        // FCalc_Enc_Start
                SendData[2] = 1;        // FCalc_Enc_Interval
                SendData[3] = 0;        // FCalc_Enc_Iteration        0 : Infinite
                SendData[4] = 0;        // FCalc_WD_Sel
                data_num = 5;
                rtn = SJUartRawBurstSend<ulong>(SJT_FPGA_CALC_MODE_SET, ref SendData, (byte)data_num);

                if ((DebugMode == 1) && (true == IsConnected()))
                {
                    //        CStringA Tmp;
                    //        for (i = 0; i < data_num; i++) Tmp_TrigSet[i] = (__int64)SendData[i];    // for debug;
                    //        Tmp.Format("Trigger GenMode 0 Trigger Set Setting : Set Num %d : rtn %x / rtn1 %x", NumberOfTrigSet, rtn, rtn1);
                    //        Put_DataLog(Tmp, (__int64*)Tmp_TrigSet, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                    Log.D(String.Format("Trigger GenMode 3 (FPGA Calc Ver) running : rtn {0:x}", rtn));
                }
            }
            // FPGA Calc condition check End//
            else
                if (timerfreq_100ns < TRIG_FREQ_MIN) return ERR_VAL_TRIG_FREQ;

            if (0 == mode) rtn = SJUartAsSingleSend(SJT_TRIG_TIMER_FREQ, timerfreq_100ns);
            else if (1 == mode) rtn = SJUartRawSingleSend(SJT_TRIG_TIMER_FREQ, timerfreq_100ns);

            if ((DebugMode == 1) && (true != IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Trigger GenMode 3 Timer Setting %d00ns : rtn %x \r\n", timerfreq_100ns, rtn);        Put_Log(Tmp, *Connected_COM);

                string temp;
                Log.D(String.Format("Trigger GenMode 3 Timer Setting {0:d}00ns : rtn {1:x}", timerfreq_100ns, rtn));
            }
            return rtn;

            //Timer reference count frequency = (1sec / (1us*timerfreq))
        }

        public ushort SetTrigTimerSeq(double timerfreq_us, sbyte mode = 0)
        {
            ushort rtn = 0;
            uint timerfreq_10ns;
            timerfreq_10ns = (uint)(timerfreq_us * 100);

            rtn = SetTrigTimerSeq(timerfreq_10ns, mode);

            return rtn;

            //Timer reference count frequency = (1sec / (1us*timerfreq))
        }

        public ushort RunTrigTimerMode(sbyte mode = 0)
        {
            //    unsigned short data=0;
            uint data = 0;
            byte TrigMode;         // 0 bit : Enc Mode(1) / Timer (0)
                                   //    unsigned char DisplayMode;        // 1 bit : Trigger Count Display (1) / Enc count Display(0)
                                   //    unsigned char Reset;            // 2 bit
            byte CntClear;         // 3 bit : Counter Clear(1)
                                   //    unsigned char TrigEncModOut_Enable;    // 4 bit : Trig out Enable(1) / Disable(0)
            byte TrigTimerModOut_Enable;   // 5bit : Trig out Timer Enable(1) / Disable(0)
            byte VitualEnc_Enable;     // 6 bit : VitualEnc input enable(1) / TrigMode must be Enc mode(1)
            byte VitualEncinput;       // 7 bit : (1)가상 Enc Input A,B상 교차입력(역방향) / (0)가상 Enc Input A,B상 정상입력(정방향)
                                       //    unsigned char Encoder_start;        // 15 bit : 1 ? Encoder Start
            ushort rtn = 0;

            TrigMode = 0;
            CntClear = 0;
            TrigTimerModOut_Enable = 1;
            VitualEnc_Enable = 0; VitualEncinput = 0;


            data = Convert.ToUInt32((TrigMode & 0x1) |
                //        ((DisplayMode & 0x1 ) << 1 ) |
                //        ((Reset & 0x1) << 2 ) |
                ((CntClear & 0x1) << 3) |
                //        ((TrigEncModOut_Enable & 0x1) << 4 ) |
                ((TrigTimerModOut_Enable & 0x1) << 5) |
                ((VitualEnc_Enable & 0x1) << 6) |
                ((VitualEncinput & 0x1) << 7));
            //        ((Encoder_start & 0x1) << 15);

            rtn = SetTrigOutEnable(false);
            rtn = SetFNDMode(1);
            rtn = SJUartAsSingleSend(SJT_TRIGSTATUS, data);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Run Trigger Timer Mode / TrigMode %d / CntClear %d / TrigTimerModOut_Enable %d / VitualEnc_Enable %d / VitualEncinput %d : rtn %x \r\n", TrigMode, CntClear, TrigTimerModOut_Enable, VitualEnc_Enable, VitualEncinput, rtn);
                //        Put_Log(Tmp, *Connected_COM);
                // <HairPinTwister> Log.D(String.Format("Run Trigger Timer Mode / TrigMode {0:d} / CntClear {1:d} / TrigTimerModOut_Enable {2:d} / VitualEnc_Enable {3:d} / VitualEncinput {5:d} : rtn {6:x}", TrigMode, CntClear, TrigTimerModOut_Enable, VitualEnc_Enable, VitualEncinput, rtn));

                Log.D(String.Format("Run Trigger Timer Mode / TrigMode {0:d} / CntClear {1:d} / TrigTimerModOut_Enable {2:d} / VitualEnc_Enable {3:d} / VitualEncinput {4:d} : rtn {5:x}", TrigMode, CntClear, TrigTimerModOut_Enable, VitualEnc_Enable, VitualEncinput, rtn));
            }
            return rtn;
        }

        ushort SetTrigPulse_(uint trigpulse, sbyte mode = 0)
        {
            ushort rtn = 0;
            if (0 == mode) rtn = SJUartAsSingleSend(SJT_TRIGPULSEWIDTH, trigpulse);
            else if (1 == mode) rtn = SJUartRawSingleSend(SJT_TRIGPULSEWIDTH, trigpulse);

            if ((DebugMode >= 2) && (true == IsConnected()))
            {
                //CStringA Tmp;
                //Tmp.Format("Single Send 32Bit : Addr 0x%x / RAW mode %d / Data 0x%x: rtn %x \r\n", SJT_TRIGPULSEWIDTH, mode, trigpulse, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Single Send 32Bit : Addr 0x{0:x} / RAW mode {1:d} / Data 0x{2:x}: rtn {3:x}", SJT_TRIGPULSEWIDTH, mode, trigpulse, rtn));
            }
            return rtn;
        }


        public ushort SetTrigPulse(uint trigpulse_us, sbyte mode = 0)
        {
            ushort rtn = 0;

            if ((trigpulse_us < TRIG_PULSEWIDTH_MIN) || (trigpulse_us > TRIG_PULSEWIDTH_MAX)) return ERR_VAL_TRIG_PULSEWIDTH;
            else
            {
                m_iTrigPulseWidth_us = trigpulse_us;
                rtn = SetTrigPulse_(m_iTrigPulseWidth_us, mode);

                if ((DebugMode == 1) && (true == IsConnected()))
                {
                    //            CStringA Tmp;
                    //            Tmp.Format("Set Trigger pulse (Generation signal) %d us / RAW mode %d : rtn %x \r\n", trigpulse_us, mode, rtn);        Put_Log(Tmp, *Connected_COM);
                    Log.D(String.Format("Set Trigger pulse (Generation signal) {0:d} us / RAW mode {1:d} : rtn {2:x}", trigpulse_us, mode, rtn));
                }
                return rtn;
            }
        }

        public ushort GetTrigPulse(ref uint trigpulse_us) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetEncDirection(uint EncDirection)
        {
            ushort rtn = 0;
            if (EncDirection > 1) return ERR_VAL_ENC_DIRECTION;
            rtn = SJUartRawSingleSend(SJT_ENC_DIRECTION, EncDirection);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Enc Direction Set %d : rtn %x \r\n", EncDirection, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Enc Direction Set {0:d} : rtn {1:x}", EncDirection, rtn));
            }

            return rtn;
        }

        public ushort GetEncDirection(ref uint EncDirection)
        {
            ushort rtn = 0;
            rtn = SJUartSingleRecv(SJT_TRIG_CNT, ref EncDirection);
            return rtn;
        }

        public ushort SetFNDMode(byte FND_Mode, sbyte mode = 0)
        {
            uint data = 0;
            ushort rtn = 0;

            data = Convert.ToUInt32(0xff & FND_Mode);
            rtn = SJUartAsSingleSend(SJT_FND_CHANGE, data);
            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("FNDMode Change: rtn %x \r\n", FND_Mode, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("FNDMode Change: rtn {0:x}", FND_Mode, rtn));
            }
            return rtn;

        }

        //        INT16U EncoderWrapper::GetTrigNErrCnt(unsigned int* TrigCount, unsigned int* ErrCount)
        //        {
        //            INT16U rtn = 0;
        //            unsigned __int64 Tmp_Cur_EncCnt[17];
        //            rtn = SJUartRawBurstRecv(SJT_TRIG_CNT, &Tmp_Cur_EncCnt[0], 17);
        //            if (0 == rtn)
        //            {
        //                TrigCount[0] = (unsigned int)Tmp_Cur_EncCnt[0];
        //                for (int i = 1; i < 17; i++)
        //                {
        //                    TrigCount[i] = (unsigned int)(Tmp_Cur_EncCnt[i] >> 32);
        //                ErrCount[i - 1] = (unsigned int)(Tmp_Cur_EncCnt[i] & 0xffffffff);
        //            }
        //        }
        //    else return rtn;

        //    if ((DebugMode == 1) && (NULL != Connected_COM)) {
        ////        CStringA Tmp;
        ////        Tmp.Format("Get Trigger Count : Total : %d : rtn %x", TrigCount[0], rtn);
        ////        Put_DataLog(Tmp, (int*)&TrigCount[1], 16, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
        ////        Tmp.Format("Get Each Channel Error Count : rtn %x", rtn);
        ////        Put_DataLog(Tmp, (int*)&ErrCount[0], 16, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
        //        string temp;
        //        temp = formatA("Get Trigger Count : Total : %d : rtn %x", TrigCount[0], rtn);
        //        Put_DataLog(temp, (int*)&TrigCount[1], 16, DATA_WR_TYPE_DEC_WRITE, * Connected_COM);
        //        temp = formatA("Get Each Channel Error Count : rtn %x", rtn);
        //        Put_DataLog(temp, (int*)&ErrCount[0], 16, DATA_WR_TYPE_DEC_WRITE, * Connected_COM);
        //    }

        //    return rtn;
        //}

        public ushort GetTrigNErrCnt(uint[] TrigCount, uint[] ErrCount, float[] MaxFreq)
        {
            ushort rtn = 0;
            ulong[] Tmp_Cur_EncCnt = new ulong[21];
            int i = 0;
            uint[] temp_ = Enumerable.Repeat<uint>(1, 16).ToArray<uint>();
            //    rtn = SJUartRawBurstRecv(SJT_TRIG_CNT, &Tmp_Cur_EncCnt[0], 17);
            //rtn = SJUartRawBurstRecv(SJT_TRIG_CNT, Tmp_Cur_EncCnt, 21);
            rtn = SJUartRawBurstRecv<ulong>(SJT_TRIG_CNT, ref Tmp_Cur_EncCnt, 21);
            if (0 == rtn)
            {
                TrigCount[0] = Convert.ToUInt32(Tmp_Cur_EncCnt[0]);
                for (i = 1; i < 17; i++)
                {
                    TrigCount[i] = Convert.ToUInt32(Tmp_Cur_EncCnt[i] >> 32);
                    ErrCount[i - 1] = Convert.ToUInt32(Tmp_Cur_EncCnt[i] & 0xffffffff);
                }
                for (i = 0; i < 4; i++)
                {
                    temp_[4 * i + 0] = Convert.ToUInt32(Tmp_Cur_EncCnt[i + 17] & Convert.ToUInt32(0xffff));
                    temp_[4 * i + 1] = Convert.ToUInt32((Tmp_Cur_EncCnt[i + 17] >> 16) & Convert.ToUInt32(0xffff));
                    temp_[4 * i + 2] = Convert.ToUInt32((Tmp_Cur_EncCnt[i + 17] >> 32) & Convert.ToUInt32(0xffff));
                    temp_[4 * i + 3] = Convert.ToUInt32((Tmp_Cur_EncCnt[i + 17] >> 48) & Convert.ToUInt32(0xffff));


                    /*            if ((unsigned int)(Tmp_Cur_EncCnt[i + 17] & (unsigned int)0xffff) == 0xfffe)    MaxFreq[i * 4 + 0] = 0.0;
                                else MaxFreq[i * 4 + 0] = 100000 / (unsigned int)(Tmp_Cur_EncCnt[i + 17] & (unsigned int)0xffff);

                                if ((unsigned int)((Tmp_Cur_EncCnt[i + 17] >> 16) & (unsigned int)0xffff) == 0xfffe)    MaxFreq[i * 4 + 1] = 0.0;
                                else MaxFreq[i * 4 + 1] = 100000 / (unsigned int)((Tmp_Cur_EncCnt[i + 17] >> 16) & (unsigned int)0xffff);

                                if ((unsigned int)((Tmp_Cur_EncCnt[i + 17] >> 32) & (unsigned int)0xffff) == 0xfffe)    MaxFreq[i * 4 + 2] = 0.0;
                                else MaxFreq[i * 4 + 2] = 100000 / (unsigned int)((Tmp_Cur_EncCnt[i + 17] >> 32) & (unsigned int)0xffff);

                                if ((unsigned int)((Tmp_Cur_EncCnt[i + 17] >> 48) & (unsigned int)0xffff) == 0xfffe)    MaxFreq[i * 4 + 3] = 0.0;
                                else MaxFreq[i * 4 + 3] = 100000 / (unsigned int)((Tmp_Cur_EncCnt[i + 17] >> 48) & (unsigned int)0xffff);*/
                }

                for (i = 0; i < 16; i++)
                {
                    if (temp_[i] == 0xfffe) MaxFreq[i] = (float)0.0;
                    else
                    {
                        if (temp_[i] != 0) MaxFreq[i] = (float)100000 / temp_[i];
                        else MaxFreq[i] = (float)0.0;
                    }
                }
            }
            else return rtn;

            //if (DebugMode == 1)
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("Get Trigger Count : Total : %d : rtn %x", TrigCount[0], rtn);
            //    //        Put_DataLog(Tmp, (int*)&TrigCount[1], 16, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
            //    //        Tmp.Format("Get Each Channel Error Count : rtn %x", rtn);
            //    //        Put_DataLog(Tmp, (int*)&ErrCount[0], 16, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
            //    string temp;
            //    temp = formatA("Get Trigger Count : Total : %d : rtn %x", TrigCount[0], rtn);
            //    Put_DataLog(temp, (int*)&TrigCount[1], 8, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
            //    temp = formatA("Get Each Channel Error Count : rtn %x", rtn);
            //    Put_DataLog(temp, (int*)&ErrCount[0], 8, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);

            //    temp = formatA("Get Each Channel Trigger Out Max Frequency : rtn %x (Unit:10 ns)", rtn);
            //    Put_DataLog(temp, (int*)&temp_[0], 8, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
            //}

            return rtn;
        }

        public ushort TrigCount_Reset()
        {
            ushort rtn = 0;
            rtn = SJT_Reset(false, false, true, false, false);
            //if ((DebugMode != 0) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("Trigger Counter Clear : rtn %x \r\n", rtn);        Put_Log(Tmp, *Connected_COM);
            //    string temp;
            //    temp = formatA("Trigger Counter Clear : rtn %x \r\n", rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode != 0) && (IsConnected() == true)) Log.D(string.Format("Trigger Counter Clear : rtn {0:x}", rtn));
            return rtn;
        }

        public ushort SetTrigOutEnable(bool TrigOutEn, sbyte mode = 0)
        {
            uint data = 0;
            ushort rtn = 0;

            data = Convert.ToUInt32(0x1 & (TrigOutEn == true ? 0x1 : 0x0));
            rtn = SJUartAsSingleSend(SJT_TRIGOUT_EN, data);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Set TrigOut Enable %d : rtn \r\n", TrigOutEn, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Set TrigOut Enable {0:d} : rtn {1:x}", TrigOutEn, rtn));
            }

            return rtn;
        }

        public ushort SetENCCnt(long EncCnt, sbyte mode = 0)
        {
            ushort rtn = 0;

            //Enc value error control needed
            //rtn = SJUartAsSingleSend(SJT_CUR_MODECNT, Convert.ToUInt32(EncCnt));
            rtn = SJUartAsSingleSend<uint>(SJT_CUR_MODECNT, Convert.ToUInt32(EncCnt));

            //if ((DebugMode == 1) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("Encoder Counter Setting : %I64d : rtn %x \r\n", EncCnt, rtn);        Put_Log(Tmp, *Connected_COM);
            //    string temp;
            //    temp = formatA("Encoder Counter Setting : %I64d : rtn %x \r\n", EncCnt, rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode != 0) && (IsConnected() == true)) Log.D(string.Format("Encoder Counter Setting : {0:d} : rtn {1:x}", EncCnt, rtn));

            return rtn;
        }
        public ushort SJT_SystemReset()
        {
            ushort rtn = 0;
            rtn = SJT_Reset(true, true, true, true, true);
            //if ((DebugMode == 1) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("SJT System Reset : rtn %x \r\n", rtn);            Put_Log(Tmp, *Connected_COM);
            //    string temp;
            //    temp = formatA("SJT System Reset : rtn %x \r\n", rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode != 0) && (IsConnected() == true)) Log.D(string.Format("SJT System Reset : rtn {0:x}", rtn));
            return rtn;
        }

        public ushort SJT_Reset(bool MB_Reset, bool RefFF_Reset, bool TrigCnt_Reset, bool Strobe_Reset, bool EncCnt_Reset)
        {
            uint data = 0;
            ushort rtn = 0;
            data = 0;
            if (MB_Reset) data |= 0x01 << 0;
            if (RefFF_Reset) data |= 0x01 << 1;
            if (TrigCnt_Reset) data |= 0x01 << 2;
            if (Strobe_Reset) data |= 0x01 << 3;
            if (EncCnt_Reset) data |= 0x01 << 4;

            //rtn = SJUartAsSingleSend(SJT_SJTRESET, data);
            rtn = SJUartAsSingleSend<uint>(SJT_SJTRESET, data);

            //if ((DebugMode >= 2) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("SJT_Reset MB_Rst %d, RefFF_Rst %d, TrigCnt_Rst %d, Strobe_Rst %d, EncCnt_Rst %d : rtn %x \r\n", MB_Reset, RefFF_Reset, TrigCnt_Reset, Strobe_Reset, EncCnt_Reset, rtn);        Put_Log(Tmp, *Connected_COM);
            //    string temp;
            //    temp = formatA("SJT_Reset MB_Rst %d, RefFF_Rst %d, TrigCnt_Rst %d, Strobe_Rst %d, EncCnt_Rst %d : rtn %x \r\n",
            //                                                        MB_Reset, RefFF_Reset, TrigCnt_Reset, Strobe_Reset, EncCnt_Reset, rtn);
            //    Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode != 0) && (IsConnected() == true)) Log.D(string.Format("SJT_Reset MB_Rst {0:d}, RefFF_Rst {1:d}, TrigCnt_Rst {2:d}, Strobe_Rst {3:d}, EncCnt_Rst {4:d} : rtn {5:x}",
                                                                    MB_Reset, RefFF_Reset, TrigCnt_Reset, Strobe_Reset, EncCnt_Reset, rtn));

            return rtn;
        }
        public ushort ENC_CNT_Reset()
        {
            ushort rtn = 0;

            rtn = SJT_Reset(true, true, true, false, true);

            //if ((DebugMode != 0) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("Encoder Counter Clear : rtn %x \r\n", rtn);        Put_Log(Tmp, *Connected_COM);
            //    string temp;
            //    temp = formatA("Encoder Counter Clear : rtn %x \r\n", rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode != 0) && (IsConnected() == true)) Log.D(string.Format("Encoder Counter Clear : rtn {0:x}", rtn));
            SJT_Trigger_Stop();

            return rtn;
        }

        public ushort DisableTrigCorrectTable()
        {
            ushort rtn = 0;
            uint data = 0;
            data = 0x1;
            rtn = SJUartAsSingleSend(SJT_POSENCTABLE_OFF, data);
            if ((DebugMode != 0) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Pos,Enc 1:1 Mode /rtn %x \r\n", rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Pos,Enc 1:1 Mode /rtn {0:x}", rtn));
            }
            return rtn;
        }

        public ushort SetTrigCorrectTable(ref double[] Pos_Table, ref ulong[] Enc_Table, sbyte mode = 0)
        {
            ulong[] SendData = new ulong[256];
            byte data_num = 0;
            ushort rtn = 0;

            if ((Pos_Table[0] != 0.0) | (Enc_Table[0] != 0))
                return ERR_VAL_POS_ENC_TABLE;


            SendData[0] = 0;
            for (int i = 1; i < 256; i++)
            {
                data_num = (byte)i;
                if (Pos_Table[i] == 0.0)
                {
                    break;
                }

                if ((POS_TABLE_MIN > Pos_Table[i]) || (POS_TABLE_MAX < Pos_Table[i]))
                    return ERR_VAL_POS_ENC_TABLE;
                if ((Pos_Table[i - 1] >= Pos_Table[i]))             // array should be increase on positive value
                    return ERR_VAL_POS_ENC_TABLE;

                SendData[i] = Convert.ToUInt64((Pos_Table[i] + 0.0005) * 1000);
            }

            for (int i = 1; i < (int)data_num; i++)
            {
                if (Enc_Table[i] > ENCODER_MAX)
                    return ERR_VAL_POS_ENC_TABLE;   //All Encoder array should be positive integer

                if (Enc_Table[i - 1] >= Enc_Table[i])
                    return ERR_VAL_POS_ENC_TABLE;
            }

            rtn = SJUartAsBurstSend(SJT_POS_TABLE_INIT, ref SendData, data_num, 0);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Pos/Enc Table Set (Pos) : DataNum %d  : rtn %x", data_num, rtn);
                //        Put_DataLog(Tmp, (__int64*)SendData, data_num, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
                Log.D(String.Format("Pos/Enc Table Set (Pos) : DataNum {0:d}  : rtn {1:x}", data_num, rtn));
                //Put_DataLog(temp, (__int64*)SendData, data_num, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
            }

            rtn |= SJUartAsBurstSend(SJT_ENC_TABLE_INIT, ref Enc_Table, data_num, 0);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Pos/Enc Table Set (Enc) : DataNum %x  : rtn %d", data_num, rtn);
                //        Put_DataLog(Tmp, (__int64*)Enc_Table, data_num, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
                Log.D(String.Format("Pos/Enc Table Set (Enc) : DataNum {0:d}  : rtn {1:x}", data_num, rtn));
                //Put_DataLog(temp, (__int64*)Enc_Table, data_num, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
            }
            return rtn;
        }

        public ushort GetCurEncoderCnt(out long Cur_EncCnt)
        {
            ushort rtn = 0;
            ulong Tmp_Cur_EncCnt = 0;
            //    rtn = SJUartSingleRecv(SJT_CUR_ENCCNT, (unsigned __int64*) Cur_EncCnt);
            //    rtn = SJUartSingleRecv(SJT_CUR_ENCCNT, &Tmp_Cur_EncCnt);
            //rtn = SJUartSingleRecv(SJT_CUR_MODECNT, out Tmp_Cur_EncCnt);
            rtn = SJUartSingleRecv<ulong>(SJT_CUR_MODECNT, ref Tmp_Cur_EncCnt);

            if (((Tmp_Cur_EncCnt >> 44) & 0x1) == 1)
                Cur_EncCnt = (Convert.ToInt64(0x7ffff) << 45) + (Convert.ToInt64(Tmp_Cur_EncCnt) & 0x1fffffffffff);

            else
                Cur_EncCnt = (Convert.ToInt64(Tmp_Cur_EncCnt) & 0x1fffffffffff);

            //if ((DebugMode == 1) && (NULL != Connected_COM))
            //{
            //    //        CStringA Tmp;
            //    //        Tmp.Format("Get Current Encoder Counter : %I64d : rtn %x \r\n", *Cur_EncCnt, rtn);        Put_Log(Tmp, *Connected_COM);
            //    string temp;
            //    temp = formatA("Get Current Encoder Counter : %I64d : rtn %x \r\n", *Cur_EncCnt, rtn); Put_Log(temp, *Connected_COM);
            //}
            if ((DebugMode != 0) && (IsConnected() == true)) Log.D(string.Format("Get Current Encoder Counter : {0:d} : rtn {1:x}", Cur_EncCnt, rtn));

            return rtn;
        }
        public ushort GetCurPosition(out long Cur_Position)
        {
            ushort rtn = 0;
            ulong Tmp_RefCnt = 0;

            //    rtn = SJUartSingleRecv(SJT_CUR_POS, (unsigned __int64*)Cur_Position);
            rtn = SJUartSingleRecv(SJT_CUR_POS, ref Tmp_RefCnt);

            /*    if (((Tmp_RefCnt >> 55) & 0x1))
                    *Cur_Position = ((unsigned __int64)0xff << 56) + (Tmp_RefCnt & 0xffffffffffffff);
                else
                    *Cur_Position = (Tmp_RefCnt & 0xffffffffffffff);
                    */
            Cur_Position = (long)(Tmp_RefCnt / 1000);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Get Current Position : %I64d : rtn %x \r\n", *Cur_Position, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Get Current Position : {0:d} : rtn {1:x}", Cur_Position, rtn));
            }
            return rtn;
        }

        public ushort SetTrigSet(byte NumberOfTrigSet, ref TrigSeqSet[] TrigSet)
        {    // Trig Gen Mode 0;
            ulong[] SendData = new ulong[509];
            int dir, i;
            ushort data_num;
            ushort rtn = 0, rtn1 = 0;
            long[] Tmp_TrigSet = new long[509];
            uint SeqVerchk = 0;
            uint RcvTmp = 0;
            uint[] RcvTmpt = new uint[2];
            uint Check_Cur_Mode, GenMode, OutMode;
            string temp = "";
            if (7 == TrigSet[0].Out2_SeqMode_Sel) TrigSet[0].Out2_SeqMode_Sel = 0;

            if (TrigSet[0].Interval > 0.0) dir = 0;
            else if (TrigSet[0].Interval == 0.0) return ERR_VAL_TRIGSET_ARRAY;
            else dir = 1;

            // FPGA PL Calc condition check Start//
            i = 1;
            while ((i-- > 0))
            {
                if (1 != NumberOfTrigSet)
                {
                    temp = String.Format("GenMode 0(FPGA Calc) Fail for Number Of TrigSet : {0:d}", NumberOfTrigSet);
                    break;
                }
                //fractal check

                if ((long)(TrigSet[0].Interval * 1000) % 1000 != 0)
                {
                    temp = String.Format("GenMode 0(FPGA Calc) Fail for TrigInterbal : {0:f}", TrigSet[0].Interval);
                    break;
                }

                if ((long)(TrigSet[0].StartPosition * 1000) % 1000 != 0)
                {
                    temp = String.Format("GenMode 0(FPGA Calc) Fail for TrigStart_Pos : {0:f}", TrigSet[0].StartPosition);
                    break;
                }

                /*        if (fmod(TrigSet[0].TrigInterbal, (double)1.0) != 0.0)
                            break;
                        if (fmod(TrigSet[0].TrigStart_Pos, (double)1.0) != 0.0)
                            break;*/

                //position mapping not use check
                rtn = SJUartRawSingleRecv(SJT_POSENCTABLE_OFF, ref RcvTmp);
                if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;
                if (0 == RcvTmp)
                {
                    temp = String.Format("GenMode 0(FPGA Calc) Fail for using Enc/Pos Err map");
                    break;
                }

                //genmode outmode check
                //support check
                //        rtn = SJUartRawSingleRecv(SJT_TRIG_GEN_OUT_MODE, &Check_Cur_Mode);
                rtn = SJUartRawBurstRecv(SJT_TRIG_GEN_OUT_MODE, ref RcvTmpt, 2);
                if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

                GenMode = RcvTmpt[0] & 0xf; OutMode = (RcvTmpt[0] >> 16) & 0x7f;
                if (((0 == GenMode) || (3 == GenMode)) && ((2 == OutMode) || (3 == OutMode)) && (1912 == RcvTmpt[1]))
                {
                    // FPGA CALC Code

                    if ((TrigSet[0].StartPosition > POSITION_MAX) || (TrigSet[0].StartPosition < POSITION_MIN))
                        return ERR_VAL_TRIGSET_ARRAY;       // Initial value error
                                                            //            if (TrigSet[0].Out2_SeqMode_Sel > 8)
                                                            //                return ERR_VAL_TRIGSET_ARRAY;        // OutMode2 MaskSeq Set error
                    if (TrigSet[0].WD_Set_Sel > 7)
                        return ERR_VAL_TRIGSET_ARRAY;       // Width Delay Set error

                    SendData[0] = 1;        //FCalc_Mode_Set
                    SendData[1] = (ulong)(TrigSet[0].StartPosition / (long)1);     // FCalc_Enc_Start
                    SendData[2] = (ulong)(TrigSet[0].Interval / (long)1);      // FCalc_Enc_Interval
                    SendData[3] = (ulong)TrigSet[0].Iteration;                        // FCalc_Enc_Iteration
                    SendData[4] = (ulong)TrigSet[0].WD_Set_Sel;                       // FCalc_WD_Sel
                    data_num = 5;
                    rtn = SJUartRawBurstSend(SJT_FPGA_CALC_MODE_SET, ref SendData, (byte)data_num);

                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //        CStringA Tmp;
                        //        for (i = 0; i < data_num; i++) Tmp_TrigSet[i] = (__int64)SendData[i];    // for debug;
                        //        Tmp.Format("Trigger GenMode 0 Trigger Set Setting : Set Num %d : rtn %x / rtn1 %x", NumberOfTrigSet, rtn, rtn1);
                        //        Put_DataLog(Tmp, (__int64*)Tmp_TrigSet, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);

                        for (i = 0; i < data_num; i++) Tmp_TrigSet[i] = (long)SendData[i];   // for debug;
                        temp = String.Format("Trigger GenMode 0(FPGA Calc Ver) Trigger Set Setting : Set Num {0:d} : rtn {1:x}", NumberOfTrigSet, rtn);
                        //Put_DataLog(temp, (__int64*)Tmp_TrigSet, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                    }

                    return rtn;
                }
                else
                {
                    temp = String.Format("GenMode 0(FPGA Calc) Fail for GenMode : {0:d} / OutMode : {1:d} / HW Support {2:d},", GenMode, OutMode, RcvTmpt[1]);
                    break;
                }
            }
            if ((DebugMode == 1) && (true == IsConnected()))
                Log.D(temp);
            // FPGA Calc condition check End//

            rtn = SJUartRawSingleRecv(SJT_SEQ_IMPROVE_CHK, ref SeqVerchk);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

            if (1912 == SeqVerchk)
            {       // Check for Trigger firmware support FPGA PL Calc mode
                if ((NumberOfTrigSet > 160) || (NumberOfTrigSet < 1)) return ERR_VAL_TRIGSET_ARRAY;
                data_num = (ushort)(NumberOfTrigSet * 3 + 1);

                for (i = 0; i < NumberOfTrigSet; i++)
                {
                    //            if ((TrigSet[i].Iteration_Num > GENMODE0_ITERATION_MAX) || (TrigSet[i].Iteration_Num == 0))
                    //                return ERR_VAL_TRIGSET_ARRAY;        // Maximum Iteration Num limit (1048575 ==> 20bit)
                    if ((TrigSet[i].StartPosition > POSITION_MAX) || (TrigSet[i].StartPosition < POSITION_MIN))
                        return ERR_VAL_TRIGSET_ARRAY;       // Initial value error

                    if (TrigSet[i].Out2_SeqMode_Sel > 8)
                        return ERR_VAL_TRIGSET_ARRAY;       // OutMode2 MaskSeq Set error

                    if (TrigSet[i].WD_Set_Sel > 7)
                        return ERR_VAL_TRIGSET_ARRAY;       // Width Delay Set error
                }

                if (dir == 0)
                {
                    for (i = 0; i < NumberOfTrigSet; i++)
                    {
                        //                if (((__int64)TrigSet[i].TrigInterbal) <= 0)    //221107 bug fix by SJ  -> less than 0.9999 ex) interbal = 0.073
                        if (TrigSet[i].Interval < 0.0)
                            return ERR_VAL_TRIGSET_ARRAY;
                    }

                    for (i = 1; i < NumberOfTrigSet; i++)
                        if (TrigSet[i - 1].StartPosition + (TrigSet[i - 1].Interval * (TrigSet[i - 1].Iteration - 1)) >= TrigSet[i].StartPosition)
                            return ERR_VAL_TRIGSET_ARRAY;
                }
                else
                {   // dir == 1
                    for (i = 0; i < NumberOfTrigSet; i++)
                    {
                        //                if (((__int64)TrigSet[i].TrigInterbal) >= 0)    //221107 bug fix by SJ
                        if (TrigSet[i].Interval > 0.0)
                            return ERR_VAL_TRIGSET_ARRAY;
                    }

                    for (i = 1; i < NumberOfTrigSet; i++)
                        if (TrigSet[i - 1].StartPosition + (TrigSet[i - 1].Interval * (TrigSet[i - 1].Iteration - 1)) <= TrigSet[i].StartPosition)
                            return ERR_VAL_TRIGSET_ARRAY;
                }

                SendData[0] = (ulong)NumberOfTrigSet;
                SendData[0] |= (0xffff & (ulong)1912) << 16;

                // double change to int  *1000  --> ex) (double) 2.24567 --> 2246 (int)
                for (i = 0; i < NumberOfTrigSet; i++)
                {

                    if (TrigSet[i].StartPosition >= 0.0) SendData[(i * 3) + 1] = (ulong)(0x1fffffffffff & ((long)((TrigSet[i].StartPosition + 0.0005) * 1000)));
                    else SendData[(i * 3) + 1] = (ulong)(0x1fffffffffff & ((long)((TrigSet[i].StartPosition - 0.0005) * 1000)));
                    SendData[(i * 3) + 1] |= (0xf & (ulong)(TrigSet[i].WD_Set_Sel)) << 48;
                    SendData[(i * 3) + 1] |= (0xf & (ulong)(TrigSet[i].Out2_SeqMode_Sel)) << 56;

                    if (TrigSet[i].Interval > 0.0) SendData[(i * 3) + 2] = (ulong)((long)((TrigSet[i].Interval + 0.0005) * 1000));
                    else SendData[(i * 3) + 2] = (ulong)((long)((TrigSet[i].Interval - 0.0005) * 1000));

                    SendData[(i * 3) + 3] = 0xffffffff & (uint)TrigSet[i].Iteration;
                }

            }
            else
            {       // old Version iteration max 20bit
                if ((NumberOfTrigSet > 254) || (NumberOfTrigSet < 1)) return ERR_VAL_TRIGSET_ARRAY;

                data_num = (ushort)(NumberOfTrigSet * 2 + 1);

                for (i = 0; i < NumberOfTrigSet; i++)
                {
                    if ((TrigSet[i].Iteration > GENMODE0_ITERATION_MAX) || (TrigSet[i].Iteration == 0))
                        return ERR_VAL_TRIGSET_ARRAY;       // Maximum Iteration Num limit (1048575 ==> 20bit)

                    if ((TrigSet[i].StartPosition > POSITION_MAX) || (TrigSet[i].StartPosition < POSITION_MIN))
                        return ERR_VAL_TRIGSET_ARRAY;       // Initial value error

                    if (TrigSet[i].Out2_SeqMode_Sel > 8)
                        return ERR_VAL_TRIGSET_ARRAY;       // OutMode2 MaskSeq Set error

                    if (TrigSet[i].WD_Set_Sel > 7)
                        return ERR_VAL_TRIGSET_ARRAY;       // Width Delay Set error
                }

                if (dir == 0)
                {
                    for (i = 0; i < NumberOfTrigSet; i++)
                    {
                        //                if (((__int64)TrigSet[i].TrigInterbal) <= 0)        //221107 bug fix by SJ
                        if (TrigSet[i].Interval < 0.0)
                            return ERR_VAL_TRIGSET_ARRAY;
                    }

                    for (i = 1; i < NumberOfTrigSet; i++)
                    {
                        if (TrigSet[i - 1].StartPosition + (TrigSet[i - 1].Interval * (TrigSet[i - 1].Iteration - 1)) >= TrigSet[i].StartPosition)
                            return ERR_VAL_TRIGSET_ARRAY;
                    }
                }
                else
                {   // dir == 1
                    for (i = 0; i < NumberOfTrigSet; i++)
                    {
                        //                if (((__int64)TrigSet[i].TrigInterbal) >= 0)        //221107 bug fix by SJ
                        if (TrigSet[i].Interval > 0.0)
                            return ERR_VAL_TRIGSET_ARRAY;

                    }

                    for (i = 1; i < NumberOfTrigSet; i++)
                    {
                        if (TrigSet[i - 1].StartPosition + (TrigSet[i - 1].Interval * (TrigSet[i - 1].Iteration - 1)) <= TrigSet[i].StartPosition)
                            return ERR_VAL_TRIGSET_ARRAY;
                    }
                }

                SendData[0] = (ulong)NumberOfTrigSet;

                // double change to int  *1000  --> ex) (double) 2.24567 --> 2246 (int)
                for (i = 0; i < NumberOfTrigSet; i++)
                {

                    if (TrigSet[i].StartPosition >= 0.0) SendData[(i * 2) + 1] = (ulong)(0x1fffffffffff & ((long)((TrigSet[i].StartPosition + 0.0005) * 1000)));
                    else SendData[(i * 2) + 1] = (ulong)(0x1fffffffffff & ((long)((TrigSet[i].StartPosition - 0.0005) * 1000)));
                    SendData[(i * 2) + 1] |= (0xf & (ulong)(TrigSet[i].WD_Set_Sel)) << 48;
                    SendData[(i * 2) + 1] |= (0xf & (ulong)(TrigSet[i].Out2_SeqMode_Sel)) << 56;

                    SendData[(i * 2) + 1 + 1] = 0xfffff & (uint)TrigSet[i].Iteration;           // 20bit
                                                                                                //        if (TrigSet[i * 3 + 1] < 0)            SendData[(i * 2) + 1 + 1] |= (0xfffffffffff & ((__int64)(TrigSet[i * 3 + 1] * 1000))) << 20;
                                                                                                //        else                                SendData[(i * 2) + 1 + 1] |= (0xfffffffffff & ((__int64)(TrigSet[i * 3 + 1] * 1000))) << 20;

                    if (TrigSet[i].Interval > 0.0) SendData[(i * 2) + 2] |= (ulong)(0xfffffffffff & ((long)((TrigSet[i].Interval + 0.0005) * 1000))) << 20;
                    else SendData[(i * 2) + 2] |= (ulong)(0xfffffffffff & ((long)((TrigSet[i].Interval - 0.0005) * 1000))) << 20;
                }


            }

            if (data_num > 255)
            {
                rtn = SJUartRawBurstSend(SJT_TRIGSET, ref SendData, 255);
                ulong[] SendData2 = SendData.Skip(255).ToArray();
                rtn1 = SJUartRawBurstSend(SJT_TRIGSET + 255, ref SendData2, (byte)(data_num - 255));
            }
            else
            {
                rtn = SJUartRawBurstSend(SJT_TRIGSET, ref SendData, (byte)data_num);
            }

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        for (i = 0; i < data_num; i++) Tmp_TrigSet[i] = (__int64)SendData[i];    // for debug;
                //        Tmp.Format("Trigger GenMode 0 Trigger Set Setting : Set Num %d : rtn %x / rtn1 %x", NumberOfTrigSet, rtn, rtn1);
                //        Put_DataLog(Tmp, (__int64*)Tmp_TrigSet, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                for (i = 0; i < data_num; i++) Tmp_TrigSet[i] = (long)SendData[i];   // for debug;
                Log.D(String.Format("Trigger GenMode 0({0:d} Ver) Trigger Set Setting : Set Num {1:d} : rtn {2:x} / rtn1 {3:x}", SeqVerchk, NumberOfTrigSet, rtn, rtn1));
                //                Put_DataLog(temp, (__int64*)Tmp_TrigSet, data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
            }

            return rtn;

        }

        public ushort SetMaskSet(ref byte[] MaskSet_pt)
        {
            ulong[] SendData = Enumerable.Repeat<ulong>(0, 14).ToArray<ulong>();
            uint[] SendData_F = Enumerable.Repeat<uint>(0, 9).ToArray<uint>();
            int i = 0, j = 0;
            byte data_num, temp, Available_SeqCnt;
            ushort rtn;
            uint RcvTmp = 0;

            Available_SeqCnt = 0;
            for (i = 6; i >= 0; i--) {
                //        temp = 0;
                //        for (j = 0; j < 8; j++) {
                //            temp += MaskSet_pt[i*8+j];
                //        }
                //        if (0 != temp) {
                //            Available_SeqCnt = i + 1;
                //            break;
                //        }

                for (j = 8; j >= 0; j--) {
                    temp = 0;
                    if (0 != MaskSet_pt[i * 8 + j]) {
                        temp = (byte)j;
                        Available_SeqCnt = (byte)(i + 1);
                        break;
                    }
                    if (0 != temp)
                        break;
                }
            }
            //if (0 == Available_SeqCnt) return -1;
            if (0 == Available_SeqCnt) return 0;

            // FPGA Calc Start //
            i = 1;
            while ((i-- >= 0)) {
                rtn = SJUartRawSingleRecv(SJT_FPGA_CALC_MODE_SET, ref RcvTmp);
                if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;
                if (1 != RcvTmp)
                    break;
                //        if (1 != Available_SeqCnt)
                //            return    ERR_NOT_DEVELOPED_YET;
                data_num = (byte)(1 + (j + 1));
                SendData_F[0] = (uint)(data_num - 1);
                for (j = 0; j < data_num - 1; j++)
                    SendData_F[j + 1] = MaskSet_pt[j];

                rtn = SJUartRawBurstSend(SJT_FPGA_CALC_SEQMASK_NUM, ref SendData_F, data_num);
                if ((DebugMode == 1) && (true == IsConnected())) {
                    int[] temp_data_F = new int[8];
                    Log.D(String.Format("Trigger OutMode 2(FPGA Clac Ver) SEQMASK_NUM {0:d} : rtn {1:x}", data_num - 1, rtn));
                    for (i = 0; i < 8; i++) temp_data_F[i] = (int)MaskSet_pt[i];
                    //Put_DataLog(temp, (int*)&temp_data_F[0], data_num, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                }


                return rtn;
            }
            // FPGA Calc End //

            data_num = (byte)(Available_SeqCnt * 2);

            for (i = 0; i < Available_SeqCnt; i++) {
                SendData[i * 2] = (ulong)(0x00ff & MaskSet_pt[i * 8]);
                SendData[i * 2] |= (ulong)(0x00ff & MaskSet_pt[i * 8 + 1]) << 16;
                SendData[i * 2] |= (ulong)(0x00ff & MaskSet_pt[i * 8 + 2]) << 32;
                SendData[i * 2] |= (ulong)(0x00ff & MaskSet_pt[i * 8 + 3]) << 48;
                SendData[i * 2 + 1] = (ulong)(0x00ff & MaskSet_pt[i * 8 + 4]);
                SendData[i * 2 + 1] |= (ulong)((0x00ff & MaskSet_pt[i * 8 + 5]) << 16);
                SendData[i * 2 + 1] |= (ulong)(0x00ff & MaskSet_pt[i * 8 + 6]) << 32;
                SendData[i * 2 + 1] |= (ulong)(0x00ff & MaskSet_pt[i * 8 + 7]) << 48;
            }

            rtn = SJUartRawBurstSend(SJT_MASK_SEQ_SET, ref SendData, data_num);

            if ((DebugMode == 1) && (true == IsConnected())) {
                //        CStringA Tmp;
                int[] temp_data = new int[56];
                //        Tmp.Format("Trigger OutMode 2 Mask Sequence Set / NumberofMaskSet %d : rtn %x", Available_SeqCnt, rtn);
                //        for (int i = 0; i < 56; i++) temp_data[i] = (unsigned int)MaskSet_pt[i];
                //        Put_DataLog(Tmp, (int*)&temp_data[0], Available_SeqCnt*8, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);

                Log.D(String.Format("Trigger OutMode 2 Mask Sequence Set / NumberofMaskSet {0:d} : rtn {1:x}", Available_SeqCnt, rtn));
                for (i = 0; i < 56; i++) temp_data[i] = (int)MaskSet_pt[i];
                //Put_DataLog(temp, (int*)&temp_data[0], Available_SeqCnt * 8, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
            }

            return rtn;
        }    // Trig GenOut Mode 2;

        public ushort SetMaskSet(ref ushort[] MaskSet_pt)
        {
            ulong[] SendData = new ulong[14];
            int i, j;
            byte data_num, temp, Available_SeqCnt;
            ushort rtn;

            Available_SeqCnt = 0;
            for (i = 6; i >= 0; i--)
            {
                temp = 0;
                for (j = 0; j < 8; j++)
                {
                    temp += (byte)MaskSet_pt[i * 8 + j];
                }
                if (0 != temp)
                {
                    Available_SeqCnt = (byte)(i + 1);
                    break;
                }
            }
            //if (0 == Available_SeqCnt) return -1;
            if (0 == Available_SeqCnt) return 0;

            data_num = (byte)(Available_SeqCnt * 2);

            for (i = 0; i < Available_SeqCnt; i++)
            {
                SendData[i * 2] = (ulong)(0xffff & MaskSet_pt[i * 8]);
                SendData[i * 2] |= (ulong)((0xffff & MaskSet_pt[i * 8 + 1]) << 16);
                SendData[i * 2] |= (ulong)(0xffff & MaskSet_pt[i * 8 + 2]) << 32;
                SendData[i * 2] |= (ulong)(0xffff & MaskSet_pt[i * 8 + 3]) << 48;
                SendData[i * 2 + 1] = (ulong)(0xffff & MaskSet_pt[i * 8 + 4]);
                SendData[i * 2 + 1] |= (ulong)((0xffff & MaskSet_pt[i * 8 + 5]) << 16);
                SendData[i * 2 + 1] |= (ulong)(0xffff & MaskSet_pt[i * 8 + 6]) << 32;
                SendData[i * 2 + 1] |= (ulong)(0xffff & MaskSet_pt[i * 8 + 7]) << 48;
            }

            rtn = SJUartRawBurstSend(SJT_MASK_SEQ_SET, ref SendData, data_num);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        int temp_data[56];
                //        Tmp.Format("Trigger OutMode 2 Mask Sequence Set / NumberofMaskSet %d : rtn %x", Available_SeqCnt, rtn);
                //        for (int i = 0; i < 56; i++) temp_data[i] = (unsigned int)MaskSet_pt[i];
                //        Put_DataLog(Tmp, (int*)&temp_data[0], Available_SeqCnt * 8, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);

                int[] temp_data = new int[56];
                Log.D(String.Format("Trigger OutMode 2 Mask Sequence Set / NumberofMaskSet {0:d} : rtn {1:x}", Available_SeqCnt, rtn));
                for (i = 0; i < 56; i++) temp_data[i] = (int)MaskSet_pt[i];
                //Put_DataLog(temp, (int*)&temp_data[0], Available_SeqCnt * 8, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
            }
            return rtn;
        }    // Trig GenOut Mode 2;

        public ushort SetMaskSet(uint NumberOfMaskSet, ref byte[] MaskSet_pt)
        {
            ulong[] SendData = new ulong[3] { 0, 0, 0 };
            //int dir, i;
            byte data_num;
            ushort rtn;

            if (NumberOfMaskSet > 8) return ERR_OVER_MASKSET_NUMBER;

            data_num = (byte)(((NumberOfMaskSet - 1) / 4 + 1) + 1);

            SendData[0] = (uint)(NumberOfMaskSet - 1);
            SendData[1] = (uint)(((MaskSet_pt[3] << 24) & 0xff000000));
            SendData[1] |= (uint)(((MaskSet_pt[2] << 16) & 0x00ff0000));
            SendData[1] |= (uint)(((MaskSet_pt[1] << 8) & 0x0000ff00));
            SendData[1] |= (uint)((MaskSet_pt[0] & 0x000000ff));
            SendData[2] = (uint)(((MaskSet_pt[7] << 24) & 0xff000000));
            SendData[2] |= (uint)(((MaskSet_pt[6] << 16) & 0x00ff0000));
            SendData[2] |= (uint)(((MaskSet_pt[5] << 8) & 0x0000ff00));
            SendData[2] |= (uint)((MaskSet_pt[4] & 0x000000ff));

            rtn = SJUartRawBurstSend(SJT_SEQMASKSET, ref SendData, data_num);

            return rtn;
        }    // Trig GenOut Mode 2;

        public ushort SetDirectMask(uint NumberofMask, ref byte[] DirectMask_pt)
        {
            ulong[] SendData = new ulong[255];
            uint i, divide_share, divide_mod;
            ushort rtn;
            uint Check_Cur_GenMode = 0, left_PosData = 0, Total_Data_Cnt = 0;

            uint Kintex7chk = 0;
            rtn = SJUartRawSingleRecv(SJT_70T_160T_CHK, ref Kintex7chk);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

            if ((70 == Kintex7chk) || (0 == Kintex7chk))
            {
                // data check
                if (NumberofMask > SJT_REFFIFO_MAX_70T) return ERR_VAL_DIRECTMASK;
            }
            else if (160 == Kintex7chk)
            {
                if (NumberofMask > SJT_REFFIFO_MAX_160T) return ERR_VAL_DIRECTMASK;
            }
            Total_Data_Cnt = NumberofMask / 4;
            left_PosData = Total_Data_Cnt;
            divide_share = Total_Data_Cnt / 255;
            divide_mod = Total_Data_Cnt % 255;

            // Current Trigger Gen mode check
            rtn = SJUartRawSingleRecv(SJT_TRIG_GEN_OUT_MODE, ref Check_Cur_GenMode);
            Check_Cur_GenMode = Check_Cur_GenMode & 0xff;
            if ((0 != rtn) | (1 == Check_Cur_GenMode) | (2 == Check_Cur_GenMode)) return ERR_VAL_TRIGDIRECT_GENMODE;

            rtn = SJUartAsSingleSend(SJT_MB_DATA_TYPE, (uint)3);

            for (i = 0; i < NumberofMask; i++)
            {
                if (0 == i % 4)
                {
                    SendData[(i / 4) % 255] = (ulong)(0x00ff & DirectMask_pt[i]);
                }
                else if (1 == i % 4)
                {
                    SendData[(i / 4) % 255] |= (ulong)(0x00ff & DirectMask_pt[i]) << 16;
                }
                else if (2 == i % 4)
                {
                    SendData[(i / 4) % 255] |= (ulong)(0x00ff & DirectMask_pt[i]) << 32;
                }
                else
                { //if (3 == i % 4) {
                    SendData[(i / 4) % 255] |= (ulong)(0x00ff & DirectMask_pt[i]) << 48;
                }

                if (1019 == i % 1020)
                {
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, 255);
                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("OutMode Direct Mask Setting %d : rtn %x", i, rtn);
                        //                Put_DataLog(Tmp, (int*) &DirectMask_pt[i-1019], 1020, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                        Log.D(String.Format("OutMode Direct Mask Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DataLog(temp, (int*)&DirectMask_pt[i - 1019], 1020, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                    }
                    if (rtn != OK_RETURN) return rtn;
                }
                else if (i == NumberofMask - 1)
                {
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, (byte)(((i / 4) % 255) + 1));
                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("OutMode Direct Mask Setting %d : rtn %x", i, rtn);
                        //                Put_DataLog(Tmp, (int*)&DirectMask_pt[(unsigned int)(NumberofMask / 1020)*1020], ((i / 4) % 255) + 1, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                        Log.D(String.Format("OutMode Direct Mask Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DataLog(temp, (int*)&DirectMask_pt[(unsigned int)(NumberofMask / 1020) * 1020], ((i / 4) % 255) + 1, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                    }
                    if (rtn != OK_RETURN) return rtn;
                }
            }
            return rtn;
        }

        public ushort SetDirectMask(uint NumberofMask, ref ushort[] DirectMask_pt)
        {
            ulong[] SendData = new ulong[255];
            uint i, divide_share, divide_mod;
            ushort rtn;
            uint Check_Cur_GenMode = 0, left_PosData = 0, Total_Data_Cnt = 0;

            uint Kintex7chk = 0;
            rtn = SJUartRawSingleRecv(SJT_70T_160T_CHK, ref Kintex7chk);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

            if ((70 == Kintex7chk) || (0 == Kintex7chk))
            {
                // data check
                if (NumberofMask > SJT_REFFIFO_MAX_70T) return ERR_VAL_DIRECTMASK;
            }
            else if (160 == Kintex7chk)
            {
                if (NumberofMask > SJT_REFFIFO_MAX_160T) return ERR_VAL_DIRECTMASK;
            }
            Total_Data_Cnt = NumberofMask / 4;
            left_PosData = Total_Data_Cnt;
            divide_share = Total_Data_Cnt / 255;
            divide_mod = Total_Data_Cnt % 255;

            // Current Trigger Gen mode check
            rtn = SJUartRawSingleRecv(SJT_TRIG_GEN_OUT_MODE, ref Check_Cur_GenMode);
            Check_Cur_GenMode = Check_Cur_GenMode & 0xff;
            if ((0 != rtn) | (1 == Check_Cur_GenMode) | (2 == Check_Cur_GenMode)) return ERR_VAL_TRIGDIRECT_GENMODE;

            rtn = SJUartAsSingleSend(SJT_MB_DATA_TYPE, (uint)3);

            for (i = 0; i < NumberofMask; i++)
            {
                if (0 == i % 4)
                {
                    SendData[(i / 4) % 255] = (ulong)(0xffff & DirectMask_pt[i]);
                }
                else if (1 == i % 4)
                {
                    SendData[(i / 4) % 255] |= (ulong)(0xffff & DirectMask_pt[i]) << 16;
                }
                else if (2 == i % 4)
                {
                    SendData[(i / 4) % 255] |= (ulong)(0xffff & DirectMask_pt[i]) << 32;
                }
                else
                { //if (3 == i % 4) {
                    SendData[(i / 4) % 255] |= (ulong)(0xffff & DirectMask_pt[i]) << 48;
                }

                if (1019 == i % 1020)
                {
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, 255);
                    if ((DebugMode == 1) && (true != IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("OutMode Direct Mask Setting %d : rtn %x", i, rtn);
                        //                Put_DataLog(Tmp, (int*)&DirectMask_pt[i - 1019], 1020, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                        Log.D(String.Format("OutMode Direct Mask Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DataLog(temp, (int*)&DirectMask_pt[i - 1019], 1020, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                    }
                    if (rtn != OK_RETURN) return rtn;
                }
                else if (i == NumberofMask - 1)
                {
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, (byte)(((i / 4) % 255) + 1));
                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("OutMode Direct Mask Setting %d : rtn %x", i, rtn);
                        //                Put_DataLog(Tmp, (int*)&DirectMask_pt[(unsigned int)(NumberofMask / 1020) * 1020], ((i / 4) % 255) + 1, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                        Log.D(String.Format("OutMode Direct Mask Setting {0:} : rtn {1:x}", i, rtn));
                        //Put_DataLog(temp, (int*)&DirectMask_pt[(unsigned int)(NumberofMask / 1020) * 1020], ((i / 4) % 255) + 1, DATA_WR_TYPE_HEX_WRITE, *Connected_COM);
                    }
                    if (rtn != OK_RETURN) return rtn;
                }
            }
            return rtn;
        }
        public ushort GetNextRefCnt(out long Next_RefCnt, out uint RefFF_Dcnt, out bool RefFF_pEmp, out bool RefFF_Empty, out ushort RefFF_OutMask, out byte RefFF_WD)
        {
            ushort rtn = 0, rtn1 = 0;
            uint RefFF_Status = 0;
            ulong Tmp_RefCnt = 0;

            //    rtn = SJUartSingleRecv(SJT_NEXT_REF_VAL, (unsigned __int64*)Next_RefCnt);
            rtn = SJUartSingleRecv(SJT_NEXT_REF_VAL, ref Tmp_RefCnt);
            rtn1 = SJUartSingleRecv(SJT_REF_FF_STATUS, ref RefFF_Status);
            //    RefFF_Dcnt = (unsigned short*) (RefFF_Status & 0x3fff);
            //    RefFF_pEmp = (bool*)((RefFF_Status >> 14) & 0x1);
            //    RefFF_Empty = (bool*)((RefFF_Status >> 15) & 0x1);

            RefFF_Dcnt = (RefFF_Status & 0x1ffff);
            RefFF_pEmp = ((RefFF_Status >> 30) & 0x1) == 0x1 ? true : false;
            RefFF_Empty = ((RefFF_Status >> 31) & 0x1) == 0x1 ? true : false;

            if (((Tmp_RefCnt >> 44) & 0x1) == 0x1)
                Next_RefCnt = (long)(((ulong)0x7ffff << 45) + (Tmp_RefCnt & 0x1fffffffffff));

            else
                Next_RefCnt = (long)(Tmp_RefCnt & 0x1fffffffffff);

            RefFF_OutMask = (ushort)((Tmp_RefCnt >> 48) & 0xffff);
            RefFF_WD = (byte)((Tmp_RefCnt >> 45) & 0x7);

            if ((DebugMode == 1) && (true != IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Get Next Reference Counter %I64d / Ref Buffer Dcnt %d / pEmpty %x / Empty %x : rtn %x \r\n", *Next_RefCnt, *RefFF_Dcnt, *RefFF_pEmp, *RefFF_Empty, rtn | rtn1);
                //        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Get Next Reference Counter {0:d} / Ref Buffer Dcnt {1:d} / pEmpty {2:x} / Empty {3:x} : rtn {4:x}", Next_RefCnt, RefFF_Dcnt, RefFF_pEmp, RefFF_Empty, rtn | rtn1));
            }
            //    if (*RefFF_Empty == true)    *Next_RefCnt = -1;
            return (ushort)(rtn | rtn1);
        }

        public ushort SetTrigDirect(uint NumberOfPosData, ref ulong[] TrigPosData, ref ushort[] TrigPosChMask, ref byte[] TrigPosWDSet)
        {   // Trig Gen Mode 1,2;
            ulong[] SendData = new ulong[256];
            uint dir, i, j, divide_share, divide_mod;
            ushort rtn, left_PosData;
            uint Check_Cur_GenMode = 0;

            uint Kintex7chk = 0;
            rtn = SJUartRawSingleRecv(SJT_70T_160T_CHK, ref Kintex7chk);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

            if ((70 == Kintex7chk) || (0 == Kintex7chk))
            {
                // data check
                if (NumberOfPosData > SJT_REFFIFO_MAX_70T) return ERR_OVER_TRIGDIRECT_BUFFER;
            }
            else if (160 == Kintex7chk)
            {
                if (NumberOfPosData > SJT_REFFIFO_MAX_160T) return ERR_OVER_TRIGDIRECT_BUFFER;
            }
            left_PosData = (ushort)NumberOfPosData;
            divide_share = NumberOfPosData / 255;
            divide_mod = NumberOfPosData % 255;

            if (TrigPosData[0] < TrigPosData[1]) dir = 0;
            else dir = 1;


            if (dir == 0)
            {
                for (i = 0; i < NumberOfPosData - 1; i++)
                    if (TrigPosData[i] >= TrigPosData[i + 1]) return ERR_VAL_TRIGDIRECT_ARRAY;
            }
            else
            {   // dir == 1
                for (i = 0; i < NumberOfPosData - 1; i++)
                    if (TrigPosData[i] <= TrigPosData[i + 1]) return ERR_VAL_TRIGDIRECT_ARRAY;
            }

            for (i = 0; i < NumberOfPosData - 1; i++)
            {
                if (TrigPosWDSet[i] > 7) return ERR_VAL_TRIGDIRECT_ARRAY;
                if ((TrigPosData[i] > ENCODER_MAX) || (TrigPosData[i] < ENCODER_MIN)) return ERR_VAL_TRIGDIRECT_ARRAY;
            }

            // Current Trigger Gen mode check
            rtn = SJUartRawSingleRecv(SJT_TRIG_GEN_OUT_MODE, ref Check_Cur_GenMode);
            Check_Cur_GenMode = Check_Cur_GenMode & 0xff;
            if ((0 != rtn) | (1 > Check_Cur_GenMode) | (2 < Check_Cur_GenMode)) return ERR_VAL_TRIGDIRECT_GENMODE;

            rtn = SJUartAsSingleSend(SJT_MB_DATA_TYPE, (uint)0);

            for (i = 0; i < divide_share + 1; i++)
            {
                if (left_PosData > 255)
                {
                    for (j = 0; j < 255; j++)
                    {
                        //                SendData[j] = (unsigned __int64) ((TrigPosData[i * 255 + j] << 8) + TrigPosChMask[i * 255 + j]) ;
                        SendData[j] = (ulong)((TrigPosData[i * 255 + j] << 19) + ((0x7 & (ulong)TrigPosWDSet[i * 255 + j]) << 16) + TrigPosChMask[i * 255 + j]);
                    }

                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, 255);

                    left_PosData -= 255;

                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("Trigger GenMode 1 Trigger Direct Enc Setting %d : rtn %x", i, rtn);
                        //                Put_DirectTriggerInLog(Tmp, (unsigned short*)&TrigPosChMask[i*255], (__int64*)&TrigPosData[i * 255], (unsigned char*)&TrigPosWDSet[i * 255], 255, *Connected_COM);
                        Log.D(String.Format("Trigger GenMode 1 Trigger Direct Enc Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DirectTriggerInLog(temp, (unsigned short*) & TrigPosChMask[i * 255], (__int64*)&TrigPosData[i * 255], (unsigned char*)&TrigPosWDSet[i * 255], 255, *Connected_COM);
                    }

                    if (rtn != OK_RETURN) return rtn;
                }
                else
                {
                    for (j = 0; j < divide_mod; j++)
                    {
                        SendData[j] = (ulong)((TrigPosData[i * 255 + j] << 19) + ((0x7 & (ulong)TrigPosWDSet[i * 255 + j]) << 16) + TrigPosChMask[i * 255 + j]);
                    }
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, (byte)divide_mod);

                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("Trigger GenMode 1 Trigger Direct Enc Setting %d : rtn %x", i, rtn);
                        //                Put_DirectTriggerInLog(Tmp, (unsigned short*)&TrigPosChMask[i * 255], (__int64*)&TrigPosData[i * 255], (unsigned char*)&TrigPosWDSet[i * 255], divide_mod, *Connected_COM);
                        Log.D(String.Format("Trigger GenMode 1 Trigger Direct Enc Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DirectTriggerInLog(temp, (unsigned short *) & TrigPosChMask[i * 255], (__int64*)&TrigPosData[i * 255], (unsigned char*)&TrigPosWDSet[i * 255], divide_mod, *Connected_COM);
                    }
                    if (rtn != OK_RETURN) return rtn;
                }
            }

            return rtn;
        }

        public ushort SetTrigDirect(uint NumberOfPosData, ref double[] TrigPosData, ref ushort[] TrigPosChMask, ref byte[] TrigPosWDSet)
        {    // Trig Gen Mode 1,2;
            ulong[] SendData = new ulong[256];
            uint dir, i, j, divide_share, divide_mod;
            ushort rtn, left_PosData;
            uint Check_Cur_GenMode = 0;
            long[] tmp_PosData = new long[256];

            uint Kintex7chk = 0;
            rtn = SJUartRawSingleRecv(SJT_70T_160T_CHK, ref Kintex7chk);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;

            if ((70 == Kintex7chk) || (0 == Kintex7chk))
            {
                // data check
                if (NumberOfPosData > SJT_REFFIFO_MAX_70T) return ERR_OVER_TRIGDIRECT_BUFFER;
            }
            else if (160 == Kintex7chk)
            {
                if (NumberOfPosData > SJT_REFFIFO_MAX_160T) return ERR_OVER_TRIGDIRECT_BUFFER;
            }
            left_PosData = (ushort)NumberOfPosData;
            divide_share = NumberOfPosData / 255;
            divide_mod = NumberOfPosData % 255;

            if (TrigPosData[0] < TrigPosData[1]) dir = 0;
            else dir = 1;

            if (dir == 0)
            {
                for (i = 0; i < NumberOfPosData - 1; i++)
                    if (TrigPosData[i] >= TrigPosData[i + 1]) return ERR_VAL_TRIGDIRECT_ARRAY;
            }
            else
            {   // dir == 1
                for (i = 0; i < NumberOfPosData - 1; i++)
                    if (TrigPosData[i] <= TrigPosData[i + 1]) return ERR_VAL_TRIGDIRECT_ARRAY;
            }

            for (i = 0; i < NumberOfPosData - 1; i++)
            {
                if (TrigPosWDSet[i] > 7) return ERR_VAL_TRIGDIRECT_ARRAY;
                if ((TrigPosData[i] > POSITION_MAX) || (TrigPosData[i] < POSITION_MIN)) return ERR_VAL_TRIGDIRECT_ARRAY;
            }

            // Current Trigger Gen mode check
            rtn = SJUartRawSingleRecv(SJT_TRIG_GEN_OUT_MODE, ref Check_Cur_GenMode);
            Check_Cur_GenMode = Check_Cur_GenMode & 0xff;
            if ((0 != rtn) | (1 > Check_Cur_GenMode) | (2 < Check_Cur_GenMode)) return ERR_VAL_TRIGDIRECT_GENMODE;

            rtn = SJUartAsSingleSend(SJT_MB_DATA_TYPE, (uint)1);

            for (i = 0; i < divide_share + 1; i++)
            {
                if (left_PosData > 255)
                {
                    for (j = 0; j < 255; j++)
                    {
                        //                SendData[j] = (unsigned __int64) ((TrigPosData[i * 255 + j] << 8) + TrigPosChMask[i * 255 + j]) ;
                        if (TrigPosData[i * 255 + j] >= 0.0) tmp_PosData[j] = (long)((TrigPosData[i * 255 + j] + 0.0005) * 1000);
                        else tmp_PosData[j] = (long)((TrigPosData[i * 255 + j] - 0.0005) * 1000);

                        SendData[j] = (ulong)(((0x1fffffffffff & tmp_PosData[j]) << 19) + ((0x7 & TrigPosWDSet[i * 255 + j]) << 16) + TrigPosChMask[i * 255 + j]);
                    }
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, 255);

                    left_PosData -= 255;

                    if ((DebugMode == 1) && (true != IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("Trigger GenMode 1 Trigger Direct Position Setting %d : rtn %x", i, rtn);
                        //                Put_DirectTriggerInLog(Tmp, (unsigned short*)&TrigPosChMask[i * 255], (__int64*)&tmp_PosData[0], (unsigned char*)&TrigPosWDSet[i * 255], 255, *Connected_COM);
                        Log.D(String.Format("Trigger GenMode 1 Trigger Direct Position Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DirectTriggerInLog(temp, (unsigned short *) & TrigPosChMask[i * 255], (__int64*)&tmp_PosData[0], (unsigned char*)&TrigPosWDSet[i * 255], 255, *Connected_COM);
                    }

                    if (rtn != OK_RETURN) return rtn;
                }
                else
                {
                    for (j = 0; j < divide_mod; j++)
                    {
                        if (TrigPosData[i * 255 + j] >= 0.0) tmp_PosData[j] = (long)((TrigPosData[i * 255 + j] + 0.0005) * 1000);
                        else tmp_PosData[j] = (long)((TrigPosData[i * 255 + j] - 0.0005) * 1000);

                        SendData[j] = (ulong)(((0x1fffffffffff & tmp_PosData[j]) << 19) + ((0x7 & TrigPosWDSet[i * 255 + j]) << 16) + TrigPosChMask[i * 255 + j]);
                    }
                    rtn = SJUartRawBurstSend(SJT_TRIGPOSDIRECT, ref SendData, (byte)divide_mod);

                    if ((DebugMode == 1) && (true == IsConnected()))
                    {
                        //                CStringA Tmp;
                        //                Tmp.Format("Trigger GenMode 1 Trigger Direct Position Setting %d : rtn %x", i, rtn);
                        //                Put_DirectTriggerInLog(Tmp, (unsigned short*)&TrigPosChMask[i * 255], (__int64*)&tmp_PosData[0], (unsigned char*)&TrigPosWDSet[i * 255], divide_mod, *Connected_COM);
                        Log.D(String.Format("Trigger GenMode 1 Trigger Direct Position Setting {0:d} : rtn {1:x}", i, rtn));
                        //Put_DirectTriggerInLog(temp, (unsigned short *) & TrigPosChMask[i * 255], (__int64*)&tmp_PosData[0], (unsigned char*)&TrigPosWDSet[i * 255], divide_mod, *Connected_COM);
                    }
                    if (rtn != OK_RETURN) return rtn;
                }
            }

            return rtn;
        }

        public ushort SetSimulEnc(long StartEnc, int IntervalPerSec)
        {
            ushort rtn;

            if ((ENCODER_MAX < StartEnc) || (ENCODER_MIN > StartEnc)) return ERR_VAL_ENCSETMAXMIN;
            if ((BOARD_REF_CLK < IntervalPerSec) || ((-1 * BOARD_REF_CLK) > IntervalPerSec) || (0 == IntervalPerSec)) return ERR_VAL_SIMULENC;

            double tempfloat;
            uint itempSign, itempValue, itempValue2;
            ulong[] SendData = new ulong[2];
            byte data_num;


            if (IntervalPerSec < 0)
            {
                itempSign = 1;
                itempValue = (uint)(-1 * IntervalPerSec);
            }
            else
            {
                itempSign = 0;
                itempValue = (uint)IntervalPerSec;
            }


            tempfloat = BOARD_REF_CLK / itempValue;
            itempValue2 = (uint)(tempfloat + 0.5);

            SendData[0] = ((itempSign & 0x1) << 31) | (itempValue2 & 0x7fffffff);
            SendData[1] = (ulong)StartEnc;

            data_num = 2;
            rtn = SJUartAsBurstSend(SJT_SIM_ENC_CHANGE_FREQ, ref SendData, data_num);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Simul Enc Setting -> Start Enc : %I64d / Interval %d : rtn %x \r\n", StartEnc, IntervalPerSec, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Simul Enc Setting -> Start Enc : {0:d} / Interval {1:d} : rtn {2:x}", StartEnc, IntervalPerSec, rtn));
            }
            return rtn;

        }

        public ushort SetSimulTrigLimit(uint iTrigLimit_Value)
        {
            ushort rtn;
            rtn = SJUartAsSingleSend(SJT_TRIG_LIMIT_VAL, iTrigLimit_Value);
            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Simul TriggerLimit Setting --> %d :rtn %x \r\n", m_iTrigLimit_Value, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Simul TriggerLimit Setting --> {0:d} :rtn {1:x}", iTrigLimit_Value, rtn));
            }
            return rtn;
        }

        public ushort SetCntInType(uint CntInType)
        {
            ushort rtn;
            rtn = SJUartAsSingleSend(SJT_REF_FF_MATCHING_TYPE, (uint)CntInType);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Enc / Timer Setting %d : rtn %x \r\n", CntInType, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Enc / Timer Setting {0:d} : rtn {1:x}", CntInType, rtn));
            }
            return rtn;
        }

        public ushort SetTrigMode(uint TrigGenMode, uint ChOutMode)
        {          // GenMode, OutMode integration
            ushort rtn;
            uint temp;
            if ((TrigGenMode > 4) || (TrigGenMode < 0)) return ERR_VAL_TRIGGENMODE;
            if (((ChOutMode & 0x7f) > 3) || ((ChOutMode & 0x7f) < 0)) return ERR_VAL_TRIGOUTMODE;

            temp = TrigGenMode;
            temp |= (ChOutMode << 16) & 0xffff0000;
            rtn = SJUartAsSingleSend(SJT_TRIG_GEN_OUT_MODE, temp);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Trig Gen mode : %d / Trig Out mode : %d  : rtn %x \r\n", TrigGenMode, ChOutMode, rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Trig Gen mode : {0:d} / Trig Out mode : {1:d}  : rtn {2:x}", TrigGenMode, ChOutMode, rtn));
            }
            return rtn;
        }

        public ushort GetTrigMode(ref uint TrigGenMode, ref uint ChOutMode)
        {
            ushort rtn;
            ulong Tmp_Recv = 0;

            //    rtn = SJUartSingleRecv(SJT_NEXT_REF_VAL, (unsigned __int64*)Next_RefCnt);
            rtn = SJUartSingleRecv(SJT_TRIG_GEN_OUT_MODE, ref Tmp_Recv);

            TrigGenMode = (uint)(Tmp_Recv & 0xffff);
            ChOutMode = (uint)((Tmp_Recv >> 16) & 0xffff);

            return rtn;
        }


        public ushort Debug_RefFF_Change()
        {
            ushort rtn = 0;

            rtn = SJUartAsSingleSend(SJT_REF_FF_CHANGE, (uint)0);

            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        Tmp.Format("Reference Buffer Flush : rtn %x \r\n", rtn);        Put_Log(Tmp, *Connected_COM);
                Log.D(String.Format("Reference Buffer Flush : rtn {0:x}", rtn));
            }

            return rtn;
        }

        public ushort SJT_Trigger_Start()
        {
            ushort rtn = 0;
            uint gen_mode = 0, out_mode = 0;

            GetTrigMode(ref gen_mode, ref out_mode);

            if (gen_mode == 0)
            {

            }
            else if (gen_mode == 1) { }
            else if (gen_mode == 2)
            {
                rtn = SJT_Reset(false, false, true, false, false);
            }
            else if (gen_mode == 3)
            {
                //        rtn = SJT_Reset(false, false, true, false, false);
                rtn = RunTrigTimerMode();
            }
            else if (gen_mode == 4) { }

            rtn = SJUartSingleSend(SJT_MB_START, (uint)1);
            if ((DebugMode == 1) && (true == IsConnected()))
            {
                //        CStringA Tmp;
                //        __int64 m_64iEncWhenStart;
                //        Tmp.Format("Trig Start  : rtn %x \r\n", rtn);
                //        rtn = SJUartSingleRecv(SJT_ENC_WHEN_START, (unsigned __int64*)&m_64iEncWhenStart);
                //        Put_Log(Tmp, *Connected_COM);
                //
                //        if (((m_64iEncWhenStart >> 44) & 0x1))            m_64iEncWhenStart = ((unsigned __int64)0x7ffff << 45) + (m_64iEncWhenStart & 0x1fffffffffff);
                //        else                                            m_64iEncWhenStart = (m_64iEncWhenStart & 0x1fffffffffff);
                //        Tmp.Format("Encoder When Start : %I64d  : rtn %x \r\n", m_64iEncWhenStart, rtn);        Put_Log(Tmp, *Connected_COM);

                string temp;
                long m_64iEncWhenStart = 0;
                Log.D(String.Format("Trig Start  : rtn {0:x}", rtn));
                rtn = SJUartSingleRecv(SJT_ENC_WHEN_START, ref m_64iEncWhenStart);
                if (((m_64iEncWhenStart >> 44) & 0x1) == 0x1) m_64iEncWhenStart = ((long)0x7ffff << 45) + (m_64iEncWhenStart & 0x1fffffffffff);
                else m_64iEncWhenStart = (m_64iEncWhenStart & 0x1fffffffffff);
                Log.D(String.Format("Encoder When Start : {0:d}  : rtn {1:x}", m_64iEncWhenStart, rtn));
            }

            return rtn;

        }

        public ushort SJT_Trigger_Stop()
        {
            ushort rtn = 0;
            uint[] Trig_Count = new uint[17];        //0 -> Total Matched count, 1~8 -> Each Channel Trig Out Count
            uint[] Error_Count = new uint[16];
            float[] MaxFreq = new float[16];
            rtn = SJUartSingleSend(SJT_MB_START, Convert.ToUInt32(0));

            if (0 == rtn)
            {
                //        GetTrigNErrCnt(&Trig_Count[0], &Error_Count[0]);
                GetTrigNErrCnt(Trig_Count, Error_Count, MaxFreq);
                uint err_cnt = 0;
                err_cnt = Error_Count[0] + Error_Count[1] + Error_Count[2] + Error_Count[3] + Error_Count[4] + Error_Count[5] + Error_Count[6] + Error_Count[7] +
                            Error_Count[8] + Error_Count[9] + Error_Count[10] + Error_Count[11] + Error_Count[12] + Error_Count[13] + Error_Count[14] + Error_Count[15];
                if (0 != err_cnt) rtn = ERR_TRIG_ERR_OCCURED;
                else rtn = OK_RETURN;
            }


            //    if ((DebugMode == 1) && (NULL != Connected_COM))
            //    {
            //        //        CStringA Tmp;
            //        //        INT16U rtn1 = 0;
            //        //        __int64 m_64iEncWhenStop;
            //        //        Tmp.Format("Trig Stop  : rtn %x \r\n", rtn);
            //        //        rtn1 = SJUartSingleRecv(SJT_ENC_WHEN_STOP, (unsigned __int64*)&m_64iEncWhenStop);
            //        //        if (((m_64iEncWhenStop >> 44) & 0x1))            m_64iEncWhenStop = ((unsigned __int64)0x7ffff << 45) + (m_64iEncWhenStop & 0x1fffffffffff);
            //        //        else                                            m_64iEncWhenStop = (m_64iEncWhenStop & 0x1fffffffffff);
            //        //        Put_Log(Tmp, *Connected_COM);
            //        //        Tmp.Format("Encoder When Stop : %I64d  : rtn %x \r\n", m_64iEncWhenStop, rtn1);        Put_Log(Tmp, *Connected_COM);
            //        string temp;
            //        INT16U rtn1 = 0;
            //        __int64 m_64iEncWhenStop;
            //        temp = formatA("Trig Stop  : rtn %x \r\n", rtn);
            //        rtn1 = SJUartSingleRecv(SJT_ENC_WHEN_STOP, (unsigned __int64 *) & m_64iEncWhenStop);
            //        if (((m_64iEncWhenStop >> 44) & 0x1)) m_64iEncWhenStop = ((unsigned __int64)0x7ffff << 45) +(m_64iEncWhenStop & 0x1fffffffffff);

            //else m_64iEncWhenStop = (m_64iEncWhenStop & 0x1fffffffffff);
            //        Put_Log(temp, *Connected_COM);
            //        temp = formatA("Encoder When Stop : %I64d  : rtn %x \r\n", m_64iEncWhenStop, rtn1); Put_Log(temp, *Connected_COM);
            //    }
            if ((DebugMode == 1) && (true == IsConnected()))
            {
                string temp;
                ushort rtn1 = 0;
                long m_64iEncWhenStop = 0;
                rtn1 = SJUartSingleRecv<long>(SJT_ENC_WHEN_STOP, ref m_64iEncWhenStop);
                if (((m_64iEncWhenStop >> 44) & 0x1) == 1) m_64iEncWhenStop = ((long)0x7ffff << 45) + (m_64iEncWhenStop & 0x1fffffffffff);
                else m_64iEncWhenStop = (m_64iEncWhenStop & 0x1fffffffffff);
                Log.D(String.Format("Trig Stop  : rtn {0:x}", rtn));
                Log.D(String.Format("Encoder When Stop : {0:d}  : rtn {1:x}", m_64iEncWhenStop, rtn1));
            }
            return rtn;
        }

        public ushort SetStrobe(byte Strobe_Ch, uint Mask, ref double[] StrobeData_us_pt)
        {
            ushort rtn = 0;
            uint[] StrobeSet = new uint[17];
            StrobeSet[0] = Mask;

            for (int i = 0; i < 16; i++)
            {
                if (StrobeData_us_pt[i] < 0)
                    return ERR_VAL_STROBE_NUM;
                if ((uint)StrobeData_us_pt[i] > UInt32.MaxValue)
                    return ERR_VAL_STROBE_NUM;
                StrobeSet[i + 1] = (uint)((StrobeData_us_pt[i] + 0.005) * 100);
            }

            rtn = SetStrobe(Strobe_Ch, ref StrobeSet);

            return rtn;
        }

        public ushort SetStrobe(byte StrobeCh, ref uint[] StrobeData_pt)
        {
            ushort rtn = 0;
            int addr;
            byte Data_Num;
            byte Trig_OutMode;
            uint Tmp_Recv = 0;
            //    CStringA Tmp;
            string temp;

            if ((StrobeCh > Max_OutCh - 1) || (0 > StrobeCh))
            {
                return ERR_VAL_CHANNEL_NUM;
            }
            //    rtn = SJUartSingleRecv(SJT_NEXT_REF_VAL, (unsigned __int64*)Next_RefCnt);
            rtn = SJUartSingleRecv(SJT_TRIG_GEN_OUT_MODE, ref Tmp_Recv);
            Trig_OutMode = (byte)((Tmp_Recv >> 16) & 0x7f);

            if (Trig_OutMode == (byte)ChannelOutMode.SeqBy1Trig)
            {
                addr = SJT_STROBESET + (StrobeCh * 17);
                Data_Num = 17;
                rtn = SJUartBurstSend(addr, ref StrobeData_pt, Data_Num, 0);

                if ((DebugMode == 1) && (true == IsConnected()))
                {
                    Log.D(String.Format("Trigger OutMode {0:d}, Ch {1:d} Width & Delay Setting : Mask 0x{2:x2}, DataNum {3:d}, Addr 0x{4:x} : rtn {5:x}", Trig_OutMode, StrobeCh, StrobeData_pt[0], Data_Num, addr, rtn));
                    //Put_DataLog(temp, (int*)&StrobeData_pt[1], Data_Num - 1, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
                }
            }
            else if (Trig_OutMode == (byte)ChannelOutMode.DirectMask)
            {
                addr = SJT_STROBESET + (StrobeCh * 17) + 1;
                Data_Num = 2;
                uint[] tempdata = StrobeData_pt.Skip(1).ToArray();
                rtn = SJUartBurstSend(addr, ref tempdata, Data_Num, 0);

                if ((DebugMode == 1) && (true == IsConnected()))
                {
                    Log.D(String.Format("Trigger OutMode {0:d}, Ch {1:d} Width & Delay Setting : NoMask, Width {2:d20}, delay {3:d20} / Addr 0x{4:x} : rtn {5:x}", Trig_OutMode, StrobeCh, StrobeData_pt[1], StrobeData_pt[2], addr, rtn));
                }
            }
            else if (Trig_OutMode == (byte)ChannelOutMode.SequenceMask)
            {
                addr = SJT_STROBESET + (StrobeCh * 17) + 1;
                Data_Num = 16;
                uint[] tempdata = StrobeData_pt.Skip(1).ToArray();
                rtn = SJUartBurstSend(addr, ref tempdata, Data_Num, 0);

                if ((DebugMode == 1) && (true == IsConnected()))
                {
                    Log.D(String.Format("Trigger OutMode {0:d}, Ch {1:d} Width & Delay Setting : DataNum {2:d}, Addr 0x{3:x} : rtn {4:x}", Trig_OutMode, StrobeCh, Data_Num, addr, rtn));
                    //Put_DataLog(temp, (int*)&StrobeData_pt[1], Data_Num - 1, DATA_WR_TYPE_DEC_WRITE, *Connected_COM);
                }
            }
            else if (Trig_OutMode == (byte)ChannelOutMode.Simple)
            {
                addr = SJT_STROBESET + (StrobeCh * 17);
                Data_Num = 3;
                rtn = SJUartBurstSend(addr, ref StrobeData_pt, Data_Num, 0);

                if ((DebugMode == 1) && (true == IsConnected()))
                {
                    Log.D(String.Format("Trigger OutMode {0:d}, Ch {1:d} Width & Delay Setting : Mask 0x{2:x2}, Width {3:d20}, Delay {4:d20} / Addr 0x{5:x} : rtn {6:x}", Trig_OutMode, StrobeCh, StrobeData_pt[0], StrobeData_pt[1], StrobeData_pt[2], addr, rtn));
                }
            }
            return rtn;
        }
        public ushort GetStrobe(byte StrobeCh, ref uint[] StrobeData_pt)
        {           // added by SJ 171123
            ushort rtn = 0;
            int addr;
            byte Data_Num;

            if ((StrobeCh > Max_OutCh - 1) || (0 > StrobeCh))
            {
                return ERR_VAL_CHANNEL_NUM;
            }
            addr = SJT_STROBESET + (StrobeCh * 17);
            Data_Num = 17;
            rtn = SJUartBurstRecv(addr, ref StrobeData_pt, Data_Num);
            return rtn;
        }

        public ushort GetTrigTimeFreq(out uint TrigTimeFreq_10ns)
        {
            ushort rtn;
            uint Tmp_Recv = 0;

            //    rtn = SJUartSingleRecv(SJT_NEXT_REF_VAL, (unsigned __int64*)Next_RefCnt);
            rtn = SJUartAsSingleRecv(SJT_TRIG_TIMER_FREQ, ref Tmp_Recv);

            TrigTimeFreq_10ns = Tmp_Recv;

            return rtn;
        }

        public ushort GetTrigTimeLimit(out uint TrigTimeLimit)
        {
            ushort rtn;
            uint Tmp_Recv = 0;

            //    rtn = SJUartSingleRecv(SJT_NEXT_REF_VAL, (unsigned __int64*)Next_RefCnt);
            rtn = SJUartAsSingleRecv(SJT_TRIG_LIMIT_VAL, ref Tmp_Recv);

            TrigTimeLimit = Tmp_Recv;

            return rtn;
        }

        public ushort GetEncPosMapTableUse(out EncoderPositionMap encposmapuse)
        {
            //position mapping not use check
            uint RcvTmp = 0;
            encposmapuse = EncoderPositionMap.Normal;
            ushort rtn = SJUartRawSingleRecv(SJT_POSENCTABLE_OFF, ref RcvTmp);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;
            encposmapuse = RcvTmp > 1 ? EncoderPositionMap.CustomTable : EncoderPositionMap.Normal;
            //if (0 == RcvTmp) {
            //    Log.E($"GenMode 0(FPGA Calc) Fail for using Enc/Pos Err map");
            //    return ERR_NORESPONSE;
            //}
            return rtn;
        }

        public ushort GetCntInType(out uint CntInType)
        {
            ushort rtn;
            uint RcvTmp = 0;
            CntInType = 0;
            rtn = SJUartAsSingleRecv(SJT_REF_FF_MATCHING_TYPE, ref RcvTmp);
            if (rtn != OK_RETURN) return ERR_NOT_DEVELOPED_YET;
            CntInType = RcvTmp;
            //if (0 == RcvTmp) {
            //    Log.E($"GenMode 0(FPGA Calc) Fail for using Enc/Pos Err map");
            //    return ERR_NORESPONSE;
            //}
            return rtn;
        }

        public ushort SetTriggerStartdelay(uint startDelay) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetTriggerStartdelay(ref uint startDelay) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetTriggerWidth(uint triggerWidth) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetTriggerWidth(ref uint triggerWidth) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetTriggerCnt(uint triggerCnt) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetTriggerCnt(ref uint triggerCnt) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetEncEnable(byte encEnable) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetEncEnable(ref byte encEnable) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetRunMode(byte runMode) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetRunMode(ref byte runMode) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetInputPol(byte inputPol) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetInputPol(ref byte inputPol) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetTriggerPol(byte triggerPol) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetTriggerPol(ref byte triggerPol) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetStrobeStartdelay(uint startDelay) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetStrobeStartdelay(ref uint startDelay) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetStrobeWidth(uint strobeWidth) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetStrobeWidth(ref uint strobeWidth) { return ERR_NOT_DEVELOPED_YET; }

        public ushort SetStrobePol(byte strobePol) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetStrobePol(ref byte strobePol) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetEndTrigger(ref byte endTrigger) { return ERR_NOT_DEVELOPED_YET; }

        public ushort GetError(ref byte errorCode) { return ERR_NOT_DEVELOPED_YET; }

    }
}