using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.InteropServices;
using System.Reflection;


namespace FPER
{
    class Paket
    {// ���� ������ ��Ŷ Ŭ����
        static byte[] RawSerialize(object anything)
        {// ��Ŷ Serialize �Լ� 
            int rawsize = Marshal.SizeOf(anything);
            IntPtr buffer = Marshal.AllocHGlobal(rawsize);
            Marshal.StructureToPtr(anything, buffer, false);
            byte[] rawdatas = new byte[rawsize];
            Marshal.Copy(buffer, rawdatas, 0, rawsize);
            Marshal.FreeHGlobal(buffer);
            return rawdatas;
        }
        static object RawDeserialize(byte[] rawdatas, Type anytype)
        {// ��Ŷ Deserialize �Լ� 
            object ret_obj;
            int rawsize = Marshal.SizeOf(anytype);
            if (rawsize > rawdatas.Length)
                return null;
            IntPtr buffer = Marshal.AllocHGlobal(rawsize);
            Marshal.Copy(rawdatas, 0, buffer, rawsize);
            ret_obj = Marshal.PtrToStructure(buffer, anytype);
            Marshal.FreeHGlobal(buffer);
            return ret_obj;
        }

        byte DoCalcs(byte[] bt, int size)
        {// cs ��� �Լ� 
            byte ret_byte = 0x00;
            try
            {
                int counter = 0;
                do
                {
                    ret_byte = (byte)(ret_byte ^ bt[counter]);
                    ret_byte++;
                    counter++;
                }
                while (counter < size);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte;
        }

        public int DoCheckcs(byte[] bt, int size, byte cs)
        {/// cs üũ �Լ� 
            int ret = 0;
            try
            {
                byte calcs = 0x00;
                calcs = DoCalcs(bt, size);
                if (cs == calcs)
                {
                    ret = 1;
                }
                else
                {
                    ret = 0;
                }
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret;
        }

        public byte[] CreatePKT_SayHello_To_Board(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type1 PKT = new PRTReceiver_Type1();
                int psize = (byte)default_value_define.size_PRTReceiver_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.say_hello;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadBoardStatus(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type1 PKT = new PRTReceiver_Type1();
                int psize = (byte)default_value_define.size_PRTReceiver_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.resd_tbd_state;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_WriteBoardStatus(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte RT_BaudRate, byte loop1_BaudRate, byte loop2_BaudRate, byte RT_Term, byte BD_Reset)
        { //2010.3.24_moon
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type6 PKT = new PRTReceiver_Type6();
                int psize = (byte)default_value_define.size_PRTReceiver_Type6;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_tbd_state;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = RT_BaudRate;
                PKT.Option2 = loop1_BaudRate;
                PKT.Option3 = loop2_BaudRate;
                PKT.Option4 = RT_Term;
                PKT.Option5 = BD_Reset;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_SearchRepeaterUNIT(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID)
        {
            byte[] ret_byte_data = null;

            try
            {
                PRTReceiver_Type2 PKT = new PRTReceiver_Type2();
                int psize = (byte)default_value_define.size_PRTReceiver_Type2;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.search_repeater_unit;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Repeater_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_SearchRepeaterAll(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.search_repeater_all;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = 0xff; //2010.3.24_moon All
                PKT.Option2 = 0x00;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadRepeaterPointAll(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;

            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_repeater_all;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = 0xff; //2010.3.24_moon All
                PKT.Option2 = 0x00;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_WriteRepeaterOutputUNIT(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID, byte Repeater_Out_Value)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_repeater_output_unit;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Repeater_ID;
                PKT.Option2 = Repeater_Out_Value;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadRepeaterInfoAll(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_repeater_info_all;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = 0xff; //2010.3.24_moon All
                PKT.Option2 = 0x00;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_WriteRepeaterInfoUNIT(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID, byte Repeater_Out_Value)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_repeater_info_unit;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Repeater_ID;
                PKT.Option2 = Repeater_Out_Value;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        //2010.12.05, k.s.d, repeater information block write.
        public byte[] CreatePKT_WriteRepeaterInfoAll(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID, RepeaterDataAll Repeater_Out_Value)
        {
            int psize = (byte)default_value_define.size_PRTReceiver_Type7;
            byte[] PKT = new byte[psize + 1];
            try
            {

                PKT[0] = (byte)default_value_define.prt_header_id;
                PKT[1] = RPT_loop;
                PKT[2] = TBD_ID;
                PKT[3] = (byte)psize;
                PKT[4] = (byte)prt_cmd_define.write_repeater_info_all;
                PKT[5] = IVK_ID;
                PKT[6] = RCV_ID;
                PKT[7] = 0x01;
                PKT[8] = 127;
                //PKT[7] = Repeater_ID;
                for (int i = 0; i < 127; i++)
                {
                    PKT[9 + i] = Repeater_Out_Value.Data[i].Repeater_Info;
                }

                //ret_byte_data = PKT;
                PKT[psize] = DoCalcs(PKT, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return PKT;
        }

        public byte[] CreatePKT_ResetRepeaterUNIT(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID)
        {
            byte[] ret_byte_data = null;

            try
            {
                PRTReceiver_Type2 PKT = new PRTReceiver_Type2();
                int psize = (byte)default_value_define.size_PRTReceiver_Type2;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.reset_repeater_unit;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Repeater_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        // �߰�� ��� ����
        public byte[] CreatePKT_ResetRepeaterAll(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;

            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.reset_repeater_all;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = 0xff; //2010.3.24_moon All
                PKT.Option2 = 0x00;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        // cyim 2013.3.13
        // �Է¾��� �׽�Ʈ ���� ���� ��ư�� ������ �߰�� ���� �����ϵ��� �����Ѵ� 
        // Function Overload : �߰�⸦ �����Ͽ� ����
        public byte[] CreatePKT_ResetRepeaterAll(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID)
        {
            byte[] ret_byte_data = null;

            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.reset_repeater_all;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Repeater_ID; // cyim 2013.3.13
                PKT.Option2 = 0x01;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_WriteRepeaterInputUNIT(byte RPT_loop, byte TBD_ID, byte IVK_ID, byte RCV_ID, byte Repeater_ID, byte Repeater_In_Value)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type3 PKT = new PRTReceiver_Type3();
                int psize = (byte)default_value_define.size_PRTReceiver_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.TBD_ID = TBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_repeater_input_unit;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Repeater_ID;
                PKT.Option2 = Repeater_In_Value;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_SayHello_To_IOBoard(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type1 PKT = new PRTIO_Type1();
                int psize = (byte)default_value_define.size_PRTIO_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.sayhello_to_ioboard;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadIOBoardStatus(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type1 PKT = new PRTIO_Type1();
                int psize = (byte)default_value_define.size_PRTIO_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_ioboard_status;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_WriteIOBoardStatus(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID, byte Brate, byte BD_Reset)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type3 PKT = new PRTIO_Type3();
                int psize = (byte)default_value_define.size_PRTIO_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_ioboard_status;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = Brate;
                PKT.Option2 = BD_Reset;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadIOBoardData(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type1 PKT = new PRTIO_Type1();
                int psize = (byte)default_value_define.size_PRTIO_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_ioboard_data;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_WriteIOBoardData(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID, byte dbyte_outpoint, byte ubyte_outpoint)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type3 PKT = new PRTIO_Type3();
                int psize = (byte)default_value_define.size_PRTIO_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_ioboard_data;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = dbyte_outpoint;
                PKT.Option2 = ubyte_outpoint;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadIOBoardPointData(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID, byte POINT_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type2 PKT = new PRTIO_Type2();
                int psize = (byte)default_value_define.size_PRTIO_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_ioboard_point_data;
                PKT.IVK_ID = IVK_ID;
                PKT.Option1 = POINT_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }


        public byte[] CreatePKT_WriteIOBoardPointData(byte RPT_loop, byte IOBD_ID, byte IVK_ID, byte RCV_ID, byte POINT_ID, byte POINT_STATUS)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTIO_Type3 PKT = new PRTIO_Type3();
                int psize = (byte)default_value_define.size_PRTIO_Type3;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = RPT_loop;
                PKT.BD_ID = IOBD_ID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_ioboard_point_data;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.Option1 = (byte)(0x7F + POINT_ID);
                PKT.Option2 = POINT_STATUS;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_SayHello_To_Demon(byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTDemon_Type1 PKT = new PRTDemon_Type1();
                int psize = (byte)default_value_define.size_PRTDemon_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = 0x00;
                PKT.BD_ID = 0x00;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.sayhello_to_demon;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_StartPolling(byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTDemon_Type1 PKT = new PRTDemon_Type1();
                int psize = (byte)default_value_define.size_PRTDemon_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = 0x00;
                PKT.BD_ID = 0x00;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.start_polling;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_StopPolling(byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTDemon_Type1 PKT = new PRTDemon_Type1();
                int psize = (byte)default_value_define.size_PRTDemon_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = 0x00;
                PKT.BD_ID = 0x00;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.stop_polling;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_ReadDemonStatus(byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTDemon_Type1 PKT = new PRTDemon_Type1();
                int psize = (byte)default_value_define.size_PRTDemon_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = 0x00;
                PKT.BD_ID = 0x00;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_demon_status;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        public byte[] CreatePKT_Notify_DBUpdated(byte IVK_ID, byte RCV_ID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTDemon_Type1 PKT = new PRTDemon_Type1();
                int psize = (byte)default_value_define.size_PRTDemon_Type1;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = 0x00;
                PKT.BD_ID = 0x00;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.notify_db_update;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        //����ī��Ʈ �б� ���� byte����
        public byte[] CreatePKT_ReadCommandStatus(byte IVK_ID, byte RCV_ID, int LoopNo, int BoardID, int repeaterID, int address, Char inOut
            , Char CommandType1, Char CommandType2, Char SubType, Char ApplyRange, int Status, int commid)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type_CommandStatus PKT = new PRTReceiver_Type_CommandStatus();
                int psize = 16;

                PKT.head = (byte)default_value_define.prt_header_id;    //0x02
                PKT.RPT_loop = (byte)LoopNo;        //ID ���� ����Ʈ (Loop ��ȣ)
                PKT.TBD_ID = (byte)BoardID;          //ID ���� ����Ʈ (��ź��� ID)
                PKT.length = (byte)psize;   //0x0D, ��ü Packet ����
                PKT.cmd = (byte)prt_cmd_define.read_command_status;
                PKT.IVK_ID = IVK_ID;  //Invoke ID
                PKT.RCVR_ID = RCV_ID;
                PKT.RepeaterID = (byte)repeaterID;
                PKT.Address = (byte)address;
                PKT.InOut = (byte)inOut;
                PKT.CommId = (byte)commid;
                PKT.CommandType1 = (byte)CommandType1;
                PKT.CommandType2 = (byte)CommandType2;
                PKT.SubType = (byte)SubType;
                PKT.ApplyRange = (byte)ApplyRange;
                PKT.Status = (byte)Status;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);      //cs
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        // cyim 2015.6.29 �Ƴ��αװ����� ������ ���� ���� �������� �߰�
        public byte[] CreatePKT_AnalogDetecterLevel_Write(byte IVK_ID, byte RCV_ID, int LoopNo, int BoardID, int repeaterID, byte Fault, byte PreFire, byte FireNight, byte FireDay)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type_AnalogDetecterLevel PKT = new PRTReceiver_Type_AnalogDetecterLevel();
                int psize = (byte)default_value_define.size_PRTWrite_AnalogDetecter_Level;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = (byte)LoopNo;
                PKT.TBD_ID = (byte)BoardID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.write_analogdetecter_level;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.RepeaterID = (byte)repeaterID;
                PKT.Fault = Fault;
                PKT.PreFire = PreFire;
                PKT.FireNight = FireNight;
                PKT.FireDay = FireDay;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        // cyim 2016.10.27 : ��뷮 ���ű� �Ƴ��α� ������ Ʈ���� �б�
        public byte[] CreatePKT_AnalogDetecterTrend_Read(byte IVK_ID, byte RCV_ID, int LoopNo, int BoardID, int repeaterID)
        {
            byte[] ret_byte_data = null;
            try
            {
                PRTReceiver_Type_AnalogDetecterTrend PKT = new PRTReceiver_Type_AnalogDetecterTrend();
                int psize = (byte)default_value_define.size_PRTReceiver_Type_AnalogDetecterTrend;

                PKT.head = (byte)default_value_define.prt_header_id;
                PKT.RPT_loop = (byte)LoopNo;
                PKT.TBD_ID = (byte)BoardID;
                PKT.length = (byte)psize;
                PKT.cmd = (byte)prt_cmd_define.read_analogdetecter_trend;
                PKT.IVK_ID = IVK_ID;
                PKT.RCVR_ID = RCV_ID;
                PKT.RepeaterID = (byte)repeaterID;

                ret_byte_data = RawSerialize(PKT);
                ret_byte_data[psize] = DoCalcs(ret_byte_data, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return ret_byte_data;
        }

        // LCH 2018.02.27 : ������
        // cyim 2016.10.28 : ��뷮 ���ű� �Ƴ��α� ������ ���� Block ����
        public byte[] CreatePKT_AnalogDetecterLevel_WriteAll(byte IVK_ID, byte RCV_ID, byte RPT_loop, byte TBD_ID, RepeaterDataAll AnalogDetecter)
        {
            int cnt = 0;
            for (int i = 0; i < 127; i++)
            {
                if (AnalogDetecter.Data[i].AnalogDetecter == true)
                {
                    cnt++;
                }
            }
            // �Ƴ��α� ������ ������ ���� ��Ŷ���̰� Ʋ������ ���� ��Ŷ�̴�!
            // Length : 1�� ��� 12, 2�� ��� 17 (7 + 5n)
            //int psize = (byte)(7 + 5 * cnt);
            int psize = 9 + (5 * cnt);
            byte[] PKT = new byte[psize + 1];

            // Ȯ����� ���ϴ� ���
            //int a = 300;
            //byte b = ((byte)(a >> 0)); // ���� : 0x2C
            //byte c = ((byte)(a >> 8)); // ���� : 0x01

            try
            {
                PKT[0] = (byte)default_value_define.prt_header_id;
                PKT[1] = RPT_loop;
                PKT[2] = TBD_ID;
                PKT[3] = 0x00; // Ȯ����� ��� -> 300 �̸� hex ������ 0x012C �̸�, ���� 0x01, ���� 0x2C �̴�
                PKT[4] = (byte)prt_cmd_define.write_analogdetecter_level_all;
                PKT[5] = ((byte)(psize >> 0)); // ����
                PKT[6] = ((byte)(psize >> 8)); // ����
                PKT[7] = IVK_ID;
                PKT[8] = RCV_ID;

                cnt = 0;
                for (int i = 0; i < 127; i++)
                {
                    if (AnalogDetecter.Data[i].AnalogDetecter == true)
                    {
                        int index = 9 + (5 * cnt);
                        PKT[index + 0] = (byte)(i + 1);// �Ƴ��α� ������ ���̵�
                        PKT[index + 1] = AnalogDetecter.Data[i].AnalogDetecterFault;
                        PKT[index + 2] = AnalogDetecter.Data[i].AnalogDetecterPreFire;
                        PKT[index + 3] = AnalogDetecter.Data[i].AnalogDetecterFireNight;
                        PKT[index + 4] = AnalogDetecter.Data[i].AnalogDetecterFireDay;
                        cnt++;
                    }
                }

                PKT[psize] = DoCalcs(PKT, psize);
            }
            catch (Exception ex)
            {
                Util.UErrorMessage(ex, 0, 0);
            }
            return PKT;
        }
    }
}