Beispiel #1
0
 /// <summary>
 /// 解析单字节入口函数
 /// </summary>
 /// <param name="data">待解析的字节</param>
 private void Parse_Byte(byte data)
 {
     // 如果接收到起始字节
     if (Gps_NmeaFrame.NMEA_FRAME_HEAD_BYTE == data)
     {
         // 清除帧类型指示
         mTmpFrameType = NMEA_FRAME_TYPE_NULL;
         // 清空临时缓冲字符串
         mStrBuffer = "";
         // 复位计数器
         ParseMoniterCnt = 0;
         // 清除CRC校验
         Current_Crc = 0;
         // 添加字符到缓冲
         mStrBuffer += (char)data;
         // 切换到下一个状态
         Current_State = NmeaFrame_ParseState.Head_State;
     }
     else
     {   // 如果当前状态不为空状态
         if (Current_State != NmeaFrame_ParseState.Null_State)
         {
             ParseMoniter[Current_State](data);
         }
     }
 }
Beispiel #2
0
        /// <summary>
        /// 初始化解析状态机,初始化每个动作所执行的操作
        /// </summary>
        private void NmeaParseMoniterInit()
        {
            // 初始化状态机
            ParseMoniter  = new Dictionary <NmeaFrame_ParseState, Action <byte> >();
            Current_State = NmeaFrame_ParseState.Null_State;

            //帧头状态
            ParseMoniter[NmeaFrame_ParseState.Head_State] = (byte data) =>
            {
                // 计算crc
                Current_Crc ^= data;

                // 如果获得分隔符
                if (data == Gps_NmeaFrame.NMEA_FRAME_SEPARATE_BYTE)
                {
                    string talkerid;
                    string contentid;

                    // 如果分析成功
                    if (Gps_NmeaFrame.GetHeadInfo(mStrBuffer, out talkerid, out contentid) == true)
                    {
                        // 清除缓冲
                        mStrBuffer = "";
                        // 清除计数器
                        ParseMoniterCnt = 0;

                        // 根据帧类型保存帧类型状态
                        if (contentid.Equals(NMEA_FRAME_CONTENTID_GGA))
                        {
                            mTmpFrameType = NMEA_FRAME_TYPE_GGA;
                        }
                        else if (contentid.Equals(NMEA_FRAME_CONTENTID_RMC))
                        {
                            mTmpFrameType = NMEA_FRAME_TYPE_RMC;
                        }
                        else if (contentid.Equals(NMEA_FRAME_CONTENTID_GSV))
                        {
                            mTmpFrameType = NMEA_FRAME_TYPE_GSV;
                        }
                        else if (contentid.Equals(NMEA_FRAME_CONTENTID_GAS))
                        {
                            mTmpFrameType = NMEA_FRAME_TYPE_GAS;
                        }
                        else if (contentid.Equals(NMEA_FRAME_CONTENTID_GSA))
                        {
                            mTmpFrameType = NMEA_FRAME_TYPE_GSA;
                        }
                        else if (contentid.Equals(NMEA_FRAME_CONTENTID_HPD))
                        {
                            mTmpFrameType = NMEA_FRAME_TYPE_HPD;
                        }
                        else
                        {
                            Current_State = NmeaFrame_ParseState.Null_State;
                            return;
                        }
                        // 清除缓冲数组
                        mGpsMsgBuff[mTmpFrameType].Clear();

                        // 添加帧头到头部
                        mGpsMsgBuff[mTmpFrameType].AddHead(talkerid, contentid);

                        // 切换到下一个状态
                        Current_State = NmeaFrame_ParseState.Data_State;
                    } // 分析出错
                    else
                    {   // 复位状态机
                        Current_State = NmeaFrame_ParseState.Null_State;
                    }
                } // 如果没有获得分隔符
                else
                {
                    // 添加数据到临时缓冲
                    mStrBuffer += (char)data;
                }

                // 如果索引值超出限制,直接恢复状态机
                if (ParseMoniterCnt++ > (Gps_NmeaFrame.NMEA_FRAME_HEAD_LEN - 1))
                {
                    Current_State = NmeaFrame_ParseState.Null_State;
                }
            };

            //帧数据状态
            ParseMoniter[NmeaFrame_ParseState.Data_State] = (byte data) =>
            {
                // 是否获取到了校验位指示符
                if (data == Gps_NmeaFrame.NMEA_FRAME_CRC_IDENTIFIER_BYTE)
                {
                    // 添加到缓冲区
                    mGpsMsgBuff[mTmpFrameType].AddData(mStrBuffer);
                    // 清除缓冲
                    mStrBuffer = "";
                    // 清除计数器
                    ParseMoniterCnt = 0;
                    // 跳转到CrcState
                    Current_State = NmeaFrame_ParseState.Crc_State;
                }
                else
                {
                    // 计算校验
                    Current_Crc ^= data;

                    // 是否为分隔符
                    if (data == Gps_NmeaFrame.NMEA_FRAME_SEPARATE_BYTE)
                    {
                        // 添加到缓冲区
                        mGpsMsgBuff[mTmpFrameType].AddData(mStrBuffer);
                        // 清楚缓冲区
                        mStrBuffer = "";
                    }
                    else
                    {
                        // 添加字符到缓冲
                        mStrBuffer += (char)data;
                    }
                }
                // 如果超出限制,直接复位状态机
                if (ParseMoniterCnt++ > Gps_NmeaFrame.NMEA_FRAME_DATA_LEN_MAX)
                {
                    Current_State = NmeaFrame_ParseState.Null_State;
                }
            };

            // 帧校验状态
            ParseMoniter[NmeaFrame_ParseState.Crc_State] = (byte data) =>
            {
                // 如果接收到了第一个结束字符
                if (data == Gps_NmeaFrame.NMEA_FRAME_END_IDENTIFIER1_BYTE)
                {
                    byte crc;
                    // 获取crc
                    crc = Convert.ToByte(mStrBuffer, 16);

                    if (crc == Current_Crc)
                    {
                        mGpsMsgBuff[mTmpFrameType].AddCrc(mStrBuffer);
                        Current_State = NmeaFrame_ParseState.End_State;
                        return;
                    }
                }
                else
                {
                    mStrBuffer += (char)data;
                }

                // 如果超出限制,复位状态机
                if (ParseMoniterCnt++ > Gps_NmeaFrame.NMEA_FRAME_DATA_CRC_LEN)
                {
                    Current_State = NmeaFrame_ParseState.Null_State;
                }
            };

            // 帧结束状态
            ParseMoniter[NmeaFrame_ParseState.End_State] = (byte data) =>
            {
                // 如果接收到第二个字符
                if (data == Gps_NmeaFrame.NMEA_FRAME_END_IDENTIFIER2_BYTE)
                {
                    // 处理当前帧
                    SelfDeal(mGpsMsgBuff[mTmpFrameType], mTmpFrameType);
                    // 此处需要清除帧缓冲
                    mGpsMsgBuff[mTmpFrameType].Clear();
                }
                Current_State = NmeaFrame_ParseState.Null_State;
            };
        }