public static void Register(ENUM_CMD type, CallBackFunction func)
 {
     if (!_callbacks.ContainsKey(type))
     {
         _callbacks.Add(type, func);
     }
 }
Beispiel #2
0
        public Result API_UpdataEnterUpdateMode
        (

        )
        {
#if _TRACE_OUT_PUT
            PrintMagToTxt("API_UpdataEnterUpdateMode");
#endif

            Result      result = Result.OK;
            ENUM_CMD    TxCmd  = ENUM_CMD.NOTHING;
            CommonParms common = new CommonParms();
            byte[]      buf    = new byte[57];
            Array.Clear(buf, 0, buf.Length);

            TxCmd  = ENUM_CMD.UPDAUE_ENTER_UPDATE_MODE;
            buf[0] = 0x0D;                     //Magic
            buf[1] = 0xF0;                     //Magic
            buf[2] = (byte)((int)TxCmd & 0xF); //command
            buf[3] = 0;                        //command
            buf[4] = 1;                        //Length
            buf[5] = 0;                        //Length
            buf[6] = 0;                        //Reserved
            buf[7] = 0;                        //Reserved
            buf[8] = 0;                        //0=>Enter update mode

            if (false == this.SendData(buf))
            {
                return(Result.FAILURE);
            }

            //Run report packet progress
            common.callback     = null;
            common.callbackCode = IntPtr.Zero;
            common.context      = IntPtr.Zero;
            if (CheckTagAccessPkt(common) == false)
            {
                return(Result.FAILURE);
            }



            Array.Clear(buf, 0, buf.Length);

            //Check receive data
            if (false == this.ReceiveData(TxCmd, ref buf))
            {
                return(Result.FAILURE);
            }

            //Check result
            result = ConvertResult(buf[4]);
            if (Result.OK != result)
            {
                return(result);
            }


            return(Result.OK);
        }
Beispiel #3
0
    public static void SendPkgToServer <T>(ENUM_CMD cmdID, T obj, Action <object> callback = null)
    {
        //Debug.Log("SendPkgToServer,cmd=" + cmdID);
        if (IsSingle && LocalServer.ProcessRequest(cmdID, obj, callback))
        {
            return;
        }

        byte[]      data   = Serialize(obj);
        int         length = data.Length;
        List <byte> bytes  = new List <byte>();

        bytes.AddRange(BitConverter.GetBytes((ushort)cmdID));
        bytes.AddRange(BitConverter.GetBytes((uint)length));
        bytes.AddRange(data);
        _message.Enqueue(bytes.ToArray());

        if (callback != null)
        {
            if (!callbackDict.ContainsKey(cmdID))
            {
                callbackDict[cmdID] = new List <NetworkCallback>();
            }
            callbackDict[cmdID].Add(new NetworkCallback {
                func = callback, isDelete = true
            });
        }
    }
Beispiel #4
0
 public static bool ProcessRequest <T>(ENUM_CMD cmdID, T obj, Action <object> callback = null)
 {
     if (dict.ContainsKey(cmdID))
     {
         dict[cmdID](obj, callback);
         return(true);
     }
     return(false);
 }
Beispiel #5
0
 public static void Register(ENUM_CMD type, Action <byte[]> _func)
 {
     if (!callbackDict.ContainsKey(type))
     {
         callbackDict[type] = new List <NetworkCallback>();
     }
     callbackDict[type].Add(new NetworkCallback {
         func = _func, isDelete = false
     });
 }
Beispiel #6
0
        protected bool ReceiveData
        (
            ENUM_CMD r_TxCmd,
            ref byte[]   r_btData
        )
        {
            ENUM_CMD result = ENUM_CMD.NOTHING;

            byte [] rdBuf = new byte[128];
            Array.Clear(rdBuf, 0, rdBuf.Length);

            //Reset Receive flow
            ResetRxFlow(ENMU_PKT_TYPE.UPDATE_COMMON);

            while (result != r_TxCmd)
            {
                result = this.Regular(ref rdBuf, true);

#if _TRACE_OUT_PUT
                PrintMagToTxt("ReceiveData");
#endif

                if (result == ENUM_CMD.TIME_OUT) //Timeout
                {
#if _TRACE_OUT_PUT
                    PrintMagToTxt("TIME OUT ReceiveData");
#endif


                    //Try to connect the device again
                    clsPacket.Mid_API_Close();
                    //clsPacket.TRANS_API_Close();
                    //this.LinkDevice();
                    //End by Wayne for implement high baud rate function, 2015-06-05

                    return(false);
                }

                TimeBeginPeriod(1);
                System.Threading.Thread.Sleep(5);
                TimeEndPeriod(1);
            }


            //Data ~ Data over  //only copy Data
            int Length = ENMU_UPDATE_INDEX.PKT_CRC - ENMU_UPDATE_INDEX.PKT_DATA;


            Array.Copy(rdBuf, (int)ENMU_UPDATE_INDEX.PKT_DATA,
                       r_btData, 0,
                       Length);

            return(true);
        }
Beispiel #7
0
        //Add by Wayne for improve FW upgrade feature for integrate M03X model, 2015-03-31
        public Result API_UpdateGetModelName
        (
            ref uint MainModelName
        )
        {
#if _TRACE_OUT_PUT
            PrintMagToTxt("API_UpdateGetModelName");
#endif

            Result   result = Result.OK;
            ENUM_CMD TxCmd  = ENUM_CMD.NOTHING;
            byte[]   buf    = new byte[57];
            Array.Clear(buf, 0, buf.Length);
            byte[] ModelName_buf = new byte[4];

            TxCmd  = ENUM_CMD.UPDATE_GET_MODEL_NAME;
            buf[0] = 0x0D;                     //Magic
            buf[1] = 0xF0;                     //Magic
            buf[2] = (byte)((int)TxCmd & 0xF); //command
            buf[3] = 0;                        //command
            buf[4] = 0;                        //Length
            buf[5] = 0;                        //Length
            buf[6] = 0;                        //Reserved
            buf[7] = 0;                        //Reserved

            if (false == this.SendData(buf))
            {
                return(Result.FAILURE);
            }

            Array.Clear(buf, 0, buf.Length);

            //Check receive data
            if (false == this.ReceiveData(TxCmd, ref buf))
            {
                return(Result.FAILURE);
            }

            //Check result
            result = ConvertResult(buf[4]);
            if (Result.OK != result)
            {
                return(result);
            }

            ModelName_buf[0] = buf[8];
            ModelName_buf[1] = buf[9];
            ModelName_buf[2] = buf[10];
            ModelName_buf[3] = buf[11];
            MainModelName    = BitConverter.ToUInt32(ModelName_buf, 0);

            return(Result.OK);
        }
Beispiel #8
0
//==========================Command===================================
        public Result API_UpdataGetVersion
        (
            ref MacBootLoaderVersion r_Version
        )
        {
#if _TRACE_OUT_PUT
            PrintMagToTxt("API_UpdataGetVersion");
#endif

            Result   result = Result.OK;
            ENUM_CMD TxCmd  = ENUM_CMD.NOTHING;
            byte[]   buf    = new byte[57];
            Array.Clear(buf, 0, buf.Length);

            TxCmd  = ENUM_CMD.UPDAUE_GET_VERSION;
            buf[0] = 0x0D;                     //Magic
            buf[1] = 0xF0;                     //Magic
            buf[2] = (byte)((int)TxCmd & 0xF); //command
            buf[3] = 0;                        //command
            buf[4] = 0;                        //Length
            buf[5] = 0;                        //Length
            buf[6] = 0;                        //Reserved
            buf[7] = 0;                        //Reserved


            if (false == this.SendData(buf))
            {
                return(Result.FAILURE);
            }

            Array.Clear(buf, 0, buf.Length);

            //Check receive data
            if (false == this.ReceiveData(TxCmd, ref buf))
            {
                return(Result.FAILURE);
            }

            //Check result
            result = ConvertResult(buf[4]);
            if (Result.OK != result)
            {
                return(result);
            }

            r_Version.major   = buf[11];
            r_Version.minor   = buf[10];
            r_Version.release = buf[09];

            return(Result.OK);
        }
 public static void Enqueue <T>(Socket socket, ENUM_CMD type, T obj)
 {
     using (MemoryStream stream = new MemoryStream())
     {
         ProtoBuf.Serializer.Serialize(stream, obj);
         Package package = new Package
         {
             socket = socket,
             type   = type,
             data   = stream.ToArray()
         };
         _message.Enqueue(package);
     }
 }
Beispiel #10
0
        public Result API_UpdataComplete
        (

        )
        {
#if _TRACE_OUT_PUT
            PrintMagToTxt("API_UpdataReset");
#endif

            Result   result = Result.OK;
            ENUM_CMD TxCmd  = ENUM_CMD.NOTHING;
            byte[]   buf    = new byte[57];
            Array.Clear(buf, 0, buf.Length);

            TxCmd  = ENUM_CMD.UPDAUE_COMPLETE;
            buf[0] = 0x0D;                     //Magic
            buf[1] = 0xF0;                     //Magic
            buf[2] = (byte)((int)TxCmd & 0xF); //command;
            buf[3] = 0;                        //command
            buf[4] = 0;                        //Length
            buf[5] = 0;                        //Length
            buf[6] = 0;                        //Reserved
            buf[7] = 0;                        //Reserved


            if (false == this.SendData(buf))
            {
                return(Result.FAILURE);
            }

            Array.Clear(buf, 0, buf.Length);

            //Check receive data
            if (false == this.ReceiveData(TxCmd, ref buf))
            {
                return(Result.FAILURE);
            }

            //Check result
            result = ConvertResult(buf[4]);
            if (Result.OK != result)
            {
                return(result);
            }

            return(Result.OK);
        }
Beispiel #11
0
    public static void Notify(ENUM_CMD cmd, object data)
    {
        if (callbackDict.ContainsKey(cmd))
        {
            List <NetworkCallback> callbackList = callbackDict[cmd];

            for (int i = callbackList.Count - 1; i >= 0; i--)
            {
                NetworkCallback callback = callbackList[i];
                callback.func(data);
                if (callback.isDelete)
                {
                    callbackList.RemoveAt(i);
                }
            }
        }
    }
Beispiel #12
0
        static void Receive(object obj)
        {
            Player player = obj as Player;

            while (true)
            {
                byte[] data    = new byte[6];
                int    receive = 0;
                try
                {
                    receive = player.socket.Receive(data);
                }
                catch
                {
                    PlayerDisconnect(player);
                    break;
                }

                if (receive > 0)
                {
                    MemoryStream stream = new MemoryStream(data);
                    BinaryReader binary = new BinaryReader(stream, Encoding.UTF8);
                    ENUM_CMD     type   = (ENUM_CMD)binary.ReadUInt16();
                    uint         length = binary.ReadUInt32();

                    data = new byte[length];
                    player.socket.Receive(data);
                    stream = new MemoryStream(data);

                    if (type != ENUM_CMD.CS_HERO_MOVE_REQ)
                    {
                        Ultilities.Print($"recieved message, type={type}, length={length}");
                    }
                    if (_callbacks.ContainsKey(type))
                    {
                        CallBackFunction func = _callbacks[type];
                        func(player, stream);
                    }
                }
                else
                {
                    PlayerDisconnect(player);
                    break;
                }
            }
        }
Beispiel #13
0
        protected bool ReceiveData(
                ENUM_CMD r_TxCmd,
            ref byte[]   r_btData
        )
        {
            ENUM_CMD result = ENUM_CMD.NOTHING;
            byte []  rdBuf  = new byte[128];
            Array.Clear(rdBuf, 0, rdBuf.Length);

            //Reset Receive flow
            ResetRxFlow(ENMU_PKT_TYPE.UPDATE_COMMON);

            while (result != r_TxCmd)
            {
                result = this.Regular(  ref rdBuf, true);

            #if _TRACE_OUT_PUT
                PrintMagToTxt("ReceiveData");
            #endif

                if (result == ENUM_CMD.TIME_OUT) //Timeout
                {

            #if _TRACE_OUT_PUT
                    PrintMagToTxt("TIME OUT ReceiveData");
            #endif

                    //Try to connect the device again
                    clsPacket.TRANS_API_Close();
                    this.LinkDevice();

                    return false;
                }

                TimeBeginPeriod(1);
                System.Threading.Thread.Sleep( 5 );
                TimeEndPeriod(1);
            }

            //Data ~ Data over  //only copy Data
            int Length = ENMU_UPDATE_INDEX.PKT_CRC - ENMU_UPDATE_INDEX.PKT_DATA;

            Array.Copy( rdBuf, (int)ENMU_UPDATE_INDEX.PKT_DATA,
                        r_btData, 0,
                        Length);

            return true;
        }
Beispiel #14
0
        public Result API_UpdataSendUpdateData
        (
            Updatedata r_strcData
        )
        {
#if _TRACE_OUT_PUT
            PrintMagToTxt("API_UpdataSendUpdateData");
#endif

            Result   result = Result.OK;
            ENUM_CMD TxCmd  = ENUM_CMD.NOTHING;
            byte[]   buf    = new byte[57];
            Array.Clear(buf, 0, buf.Length);

            TxCmd  = ENUM_CMD.UPDAUE_SEND_UPDATE_DATA;
            buf[0] = 0x0D;                                    //Magic
            buf[1] = 0xF0;                                    //Magic
            buf[2] = (byte)((int)TxCmd & 0xF);                //command;
            buf[3] = 0;                                       //command
            buf[4] = (byte)(r_strcData.usSize & 0xFF);        //Length
            buf[5] = (byte)((r_strcData.usSize >> 8) & 0xFF); //Length
            buf[6] = 0;                                       //Reserved
            buf[7] = 0;                                       //Reserved

            //Data========
            //Addr
            buf[8]  = (byte)(r_strcData.uiOffset & 0xFF);
            buf[9]  = (byte)((r_strcData.uiOffset >> 8) & 0xFF);
            buf[10] = (byte)((r_strcData.uiOffset >> 16) & 0xFF);
            buf[11] = (byte)((r_strcData.uiOffset >> 24) & 0xFF);

            //Flag
            buf[16] = (byte)(r_strcData.bRealRunFlag == true ? 0 : 1);   //Flag = 1 => Test mode

            //Data
            Array.Copy(r_strcData.btData, 0,
                       buf, 20,
                       r_strcData.btData.Length);

            //CRC
            uint uiCrc = 0;


            uiCrc   = API_OtherCrc32(API_OtherCrc32(uiCrc, buf, 0, 12), buf, 16, (uint)(r_strcData.usSize - 2) * 4);
            buf[12] = (byte)(uiCrc & 0xFF);
            buf[13] = (byte)((uiCrc >> 8) & 0xFF);
            buf[14] = (byte)((uiCrc >> 16) & 0xFF);
            buf[15] = (byte)((uiCrc >> 24) & 0xFF);

            if (false == this.SendData(buf))
            {
                return(Result.FAILURE);
            }

            Array.Clear(buf, 0, buf.Length);

            //Check receive data
            if (false == this.ReceiveData(TxCmd, ref buf))
            {
                return(Result.FAILURE);
            }

            //Check result
            result = ConvertResult(buf[4]);
            if (Result.OK != result)
            {
                return(result);
            }

            return(Result.OK);
        }
 public CCommandQueueItem(ENUM_CMD Command, int Channel, double TargetTemperature)
 {
     this.Command = Command;
     this.Channel = Channel;
     this.Temperature = TargetTemperature;
 }
 public CCommandQueueItem(ENUM_CMD Command, int Channel, double TargetTemperature)
 {
     this.Command     = Command;
     this.Channel     = Channel;
     this.Temperature = TargetTemperature;
 }
Beispiel #17
0
        protected ENUM_CMD Regular(
            [In, Out] ref byte[] RxBuf,
            [In]          bool   bCheckTimeOut
        )
        {
            ENUM_CMD         result = ENUM_CMD.NOTHING;
            TRANS_DEV_TYPE   enumDev = clsPacket.TRANS_API_AskDevType();

            RxCmd = ENUM_CMD.NOTHING;

            //Check time out
            if (bCheckTimeOut == true)
            {
                TimeSpan ts = new TimeSpan(DateTime.Now.Ticks - m_timeBefReg.Ticks);
                if (ts.TotalMilliseconds > 1500)
                {
            #if _TRACE_OUT_PUT
                    PrintMagToTxt("Regular: TimeOut");
            #endif

                    RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                    return ENUM_CMD.TIME_OUT;
                }
            }

            #if _TRACE_OUT_PUT
            PrintMagToTxt("Regular");
            #endif
            UInt32 RevCount = clsPacket.TRANS_API_AskRevCount();

            //USB receives one report at one time. Don't need to check every byte.
            if (enumDev == TRANS_DEV_TYPE.USB)
            {
                if ( 0 == clsPacket.TRANS_API_Read(RxBuf, RevCount) )
                    return result;

                //USB receives one report at one time. Don't need to find Pkt ID and Header.
                RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;

                if (PutPktToData(enumDev, RxBuf) == ENMU_REV_STATE.REVEICE_DONE)
                {
                    result = RxCmd;
                }

                return result;
            }

            for (int i = 0; i < RevCount; i++)
            {
                switch (RxStep)
                {
                    case ENMU_PKT_FLOW.STEP_HEADER_1:
                        RxCnt             = 0;
                        usDataSingleLenDw = 0;
                        usPktSingleLenBt  = 0;
                        usDivideNum       = 0;
                        usDivideSeq       = 0;
                        usRxCRC           = 0;
                        RxCmd             = ENUM_CMD.NOTHING;
                        result            = ENUM_CMD.NOTHING;
                        Array.Clear(RxBuf, 0, RxBuf.Length);

                        //RS232 need to check every byte.
                        clsPacket.TRANS_API_Read(RxByte, 1);
                        RxBuf[RxCnt] = RxByte[0];

                        //Check Header
                        switch (RxByte[0])
                        {
                            case (byte)'B': //Begin
                            case (byte)'E': //End
                            case (byte)'I': //Inventory
                            case (byte)'A': //Tag Access
                            case (byte)'R': //Common Response
                            case (byte)'S': //Update Common Response
                            case (byte)'F': //Update Enter Firmware configuration
                                RxCnt++;
                                RxStep++;
                                break;

                            default:
                                break;
                        }
                        break;

                    case ENMU_PKT_FLOW.STEP_HEADER_2:  //Header
                        //RS232 need to check every byte.
                        clsPacket.TRANS_API_Read(RxByte, 1);
                        RxBuf[RxCnt] = RxByte[0];

                        if (RxByte[0] == 'I')
                        {
                            RxCnt++;
                            RxStep++;
                        }
                        else
                        {
                            RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                        }

                        break;

                    case ENMU_PKT_FLOW.STEP_HEADER_3:  //Header
                        //RS232 need to check every byte.
                        clsPacket.TRANS_API_Read(RxByte, 1);
                        RxBuf[RxCnt] = RxByte[0];

                        if (RxByte[0] == 'T')
                        {
                            RxCnt++;
                            RxStep++;
                        }
                        else
                        {
                            RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                        }

                        break;

                    case ENMU_PKT_FLOW.STEP_HEADER_4:  //Header
                        //RS232 need to check every byte.
                        clsPacket.TRANS_API_Read(RxByte, 1);
                        RxBuf[RxCnt] = RxByte[0];

                        if (RxByte[0] == 'M')
                        {
                            RxCnt++;
                            RxStep++;
                        }
                        else
                        {
                            RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                        }

                        break;

                    case ENMU_PKT_FLOW.STEP_HANDLE:
                        if (PutPktToData(enumDev, RxBuf) == ENMU_REV_STATE.REVEICE_DONE)
                        {
                            result = RxCmd;
                            return result;
                        }
                        break;

                    default:
                        RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                        break;

                }//end switch

            }//end for

            return result;
        }
Beispiel #18
0
    static void Receive()
    {
        while (connected)
        {
            NetworkStream stream = tcpClient.GetStream();

            byte[]       data         = new byte[6];
            IAsyncResult headerResult = stream.BeginRead(data, 0, data.Length, null, null);
            while (!headerResult.IsCompleted)
            {
                Thread.Sleep(1);
            }
            int readNum = 0;
            try
            {
                readNum = stream.EndRead(headerResult);
            }
            catch
            {
                Disconnect();
            }
            if (readNum > 0)
            {
                MemoryStream lengthStream = new MemoryStream(data);
                BinaryReader binary       = new BinaryReader(lengthStream, Encoding.UTF8);
                ENUM_CMD     type         = (ENUM_CMD)binary.ReadUInt16();
                uint         length       = binary.ReadUInt32();

                MemoryStream bodyStream     = new MemoryStream();
                int          totalBytesRead = 0;
                byte[]       bufdata;
                if (length > 1024)
                {
                    bufdata = new byte[1024];
                }
                else
                {
                    bufdata = new byte[length];
                }

                int tick1 = Environment.TickCount;


                do
                {
                    if (stream.DataAvailable)
                    {
                        int bytesRead = stream.Read(bufdata, 0, bufdata.Length);
                        totalBytesRead += bytesRead;
                        bodyStream.Write(bufdata, 0, bytesRead);
                    }
                    else
                    {
                        Thread.Sleep(1);
                    }
                } while (totalBytesRead < length);

                float s = (Environment.TickCount - tick1) / 1000f;
                //Debug.Log("time = " + s);

                if (type != ENUM_CMD.CS_PLAYER_MOVE_NOTIFY)
                {
                    Debug.Log("receive message, type=" + type + ",length=" + length + ",totalBytesRead=" + totalBytesRead);
                }

                Package package = new Package();
                package.type = type;
                package.data = bodyStream.ToArray();
                lock (packageQueue)
                {
                    packageQueue.Enqueue(package);
                }
            }
            else
            {
                Disconnect();
            }
        }
    }
Beispiel #19
0
        protected ENMU_REV_STATE PutPktToData(
            [In] TRANS_DEV_TYPE enumDevice,
            [In] byte[]         RxBuf
        )
        {
            int Length = 0;
            int CrcLen = 0;
            UInt16 usCRC = 0;

            #if _TRACE_OUT_PUT
            PrintMagToTxt("PutPktToData");
            #endif

            try
            {
                //Get Per Packet size and remaining bytes
                switch (RxBuf[0])
                {
                    //Tag Access=====================
                    case (byte)'B': //Begin
                    case (byte)'E': //End
                        RxPktTpye = ENMU_PKT_TYPE.TAG_ACCESS;
                        usPktSingleLenBt = 24;
                        Length = usPktSingleLenBt - (int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_NUM;
                        break;

                    case (byte)'I': //Inventory
                    case (byte)'A': //Tag Access
                        RxPktTpye = ENMU_PKT_TYPE.TAG_ACCESS;
                        usPktSingleLenBt = 64;
                        Length = usPktSingleLenBt - (int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_NUM;
                        break;

                    //Common==========================
                    case (byte)'R': //Common
                        RxPktTpye = ENMU_PKT_TYPE.COMMON;
                        usPktSingleLenBt = 16;
                        Length = (int)ENMU_PKT_INDEX.END - (int)ENMU_PKT_INDEX.PKT_DEVIDE_ID;
                        break;

                    //Update==========================
                    case (byte)'F': //Update firmware mode
                        RxPktTpye = ENMU_PKT_TYPE.UPDATE_ENTER;
                        usPktSingleLenBt = 24;
                        Length = usPktSingleLenBt - (int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_NUM;
                        break;

                    case (byte)'S': //Update Common
                        RxPktTpye = ENMU_PKT_TYPE.UPDATE_COMMON;
                        usPktSingleLenBt = 64;
                        Length = usPktSingleLenBt - (int)ENMU_UPDATE_INDEX.PKT_DEVIDE_ID;
                        break;

                    default:
                        RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                        return ENMU_REV_STATE.RECEIVE_FAULT;
                        break;
                }

                //Receive data
                if (enumDevice == TRANS_DEV_TYPE.SERIAL)
                {

                    //Data is not ready. Break and wait for next loop to get.
                    if (clsPacket.TRANS_API_AskRevCount() < Length)
                    {
                        System.Threading.Thread.Sleep(5);
                        return ENMU_REV_STATE.WAIT_DATA;
                    }

                    byte[] tmp = new byte[Length];
                    Array.Clear(tmp, 0, tmp.Length);

                    //Receive data fail.
                    if (Length != clsPacket.TRANS_API_Read(tmp, (uint)Length))
                    {
                        RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;
                        return ENMU_REV_STATE.RECEIVE_FAULT;
                    }

                    Array.Copy(tmp, 0,
                                RxBuf, RxCnt,
                                tmp.Length);
                }

                RxCnt += Length;
                RxStep = ENMU_PKT_FLOW.STEP_HEADER_1;

                //Handle Data
                switch (RxPktTpye)
                {
                    case ENMU_PKT_TYPE.COMMON:
                        {
                            RxCmd   = (ENUM_CMD)RxBuf[(int)ENMU_PKT_INDEX.PKT_COMMAND_ID];
                            usRxCRC = BitConverter.ToUInt16(RxBuf, (int)ENMU_PKT_INDEX.PKT_CRC);
                            CrcLen  = (int)(ENMU_PKT_INDEX.PKT_CRC - ENMU_PKT_INDEX.PKT_HEADER);
                            break;
                        }

                    case ENMU_PKT_TYPE.TAG_ACCESS:
                        {
                            usDivideNum = RxBuf[(int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_NUM];
                            usDivideSeq = RxBuf[(int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_SEQ];
                            RxCmd = (ENUM_CMD)(BitConverter.ToInt16
                                                          (RxBuf,
                                                            (int)ENMU_TAG_PKT_INDEX.INFO_TYPE) | 0xF0);
                            /* Mod by james for large user memory, 2012-12-04 */
                            if (usDivideSeq == 1)
                            {
                                usDataSingleLenDw = BitConverter.ToUInt16(RxBuf, (int)ENMU_TAG_PKT_INDEX.INFO_LENGTH);
                            }
                            else
                            {
                                if (usDivideNum - usDivideSeq == 0)
                                {
                                    usDataSingleLenDw = (UInt16)(BitConverter.ToUInt16(RxBuf, (int)ENMU_TAG_PKT_INDEX.INFO_LENGTH) - 12 * (usDivideNum - 1));
                                }
                                else
                                {
                                    usDataSingleLenDw = 12;
                                }
                            }
                            /* End by james for large user memory, 2012-12-04 */
                            usRxCRC = BitConverter.ToUInt16(RxBuf, usPktSingleLenBt - 2);
                            CrcLen  = (ushort)(usPktSingleLenBt - 2);
                            break;
                        }

                    case ENMU_PKT_TYPE.UPDATE_ENTER:
                        {
                            usDivideNum = RxBuf[(int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_NUM];
                            usDivideSeq = RxBuf[(int)ENMU_TAG_PKT_INDEX.PKT_DEVIDE_SEQ];

                            //It uses TAG_ACCESS Packet, but reture 0x300B. Redefine to ENUM_CMD.
                            RxCmd   = ENUM_CMD.UPDAUE_ENTER_UPDATE_MODE;

                            usDataSingleLenDw = BitConverter.ToUInt16
                                                            (RxBuf,
                                                              (int)ENMU_TAG_PKT_INDEX.INFO_LENGTH);

                            usRxCRC = BitConverter.ToUInt16(RxBuf, usPktSingleLenBt - 2);
                            CrcLen  = (ushort)(usPktSingleLenBt - 2);

                            break;
                        }

                    case ENMU_PKT_TYPE.UPDATE_COMMON:
                        {
                            RxCmd   = (ENUM_CMD)(RxBuf[(int)ENMU_UPDATE_INDEX.PKT_DATA_RECMD] | 0xE0);
                            usRxCRC = BitConverter.ToUInt16(RxBuf, usPktSingleLenBt - 2);
                            CrcLen  = (ushort)(usPktSingleLenBt - 2);

                            break;
                        }

                    default:
                        break;
                }

                //Check CRC. CRC Legnth doesn't include CRC(2 bytes)
                usCRC = CrcCul(RxBuf, 0, (ushort)(CrcLen * 8)); //8 bits
                usCRC = (UInt16)(~usCRC & 0xFFFF);

            }
            catch (Exception e)
            {
            #if _TRACE_OUT_PUT
                this.PrintMagToTxt("Exception Error : PutPktToData");
            #endif
                clsPacket.TRANS_API_ClearBuffer();
                return ENMU_REV_STATE.RECEIVE_FAULT;
            }

            if (usCRC == usRxCRC)
            {
                return ENMU_REV_STATE.REVEICE_DONE;
            }
            else
            {
                return ENMU_REV_STATE.RECEIVE_FAULT;
            }
        }