parser.cpp

Read nmea file and send to com port. you can easly simulate the gps application

		double dVal = dDiff/60.0;
		if(dVal != 0.0)
		{
			m_dGGAVertSpeed = (m_dGGAOldVSpeedAlt - m_dGGAAltitude) / dVal;
		}
	}
	m_dGGAOldVSpeedAlt = m_dGGAAltitude;
	m_nGGAOldVSpeedSeconds = nSeconds;

	m_dwGGACount++;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void CNMEAParser::ProcessGPGSA(BYTE *pData)
{
	BYTE pField[MAXFIELD];
	CHAR pBuff[10];


	//
	// Mode
	//
	if(GetField(pData, pField, 0, MAXFIELD))
	{
		m_btGSAMode = pField[0];
	}

	//
	// Fix Mode
	//
	if(GetField(pData, pField, 1, MAXFIELD))
	{
		m_btGSAFixMode = pField[0] - '0';
	}

	//
	// Active satellites
	//
	for(int i = 0; i < 12; i++)
	{
		if(GetField(pData, pField, 2 + i, MAXFIELD))
		{
			pBuff[0] = pField[0];
			pBuff[1] = pField[1];
			pBuff[2] = '\0';
			m_wGSASatsInSolution[i] = atoi(pBuff);
		}
		else
		{
			m_wGSASatsInSolution[i] = 0;
		}
	}

	//
	// PDOP
	//
	if(GetField(pData, pField, 14, MAXFIELD))
	{
		m_dGSAPDOP = atof((CHAR *)pField);
		if ( m_dGSAPDOP < 3.0 ) m_bDOPCheck = TRUE;  // cglee for check
	}
	else
	{
		m_dGSAPDOP = 50.0;
	}

	//
	// HDOP
	//
	if(GetField(pData, pField, 15, MAXFIELD))
	{
		m_dGSAHDOP = atof((CHAR *)pField);
	}
	else
	{
		m_dGSAHDOP = 50.0;
	}

	//
	// VDOP
	//
	if(GetField(pData, pField, 16, MAXFIELD))
	{
		m_dGSAVDOP = atof((CHAR *)pField);
	}
	else
	{
		m_dGSAVDOP = 50.0;
	}

	m_dwGSACount++;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void CNMEAParser::ProcessGPGSV(BYTE *pData)
{
	INT nTotalNumOfMsg, nMsgNum;
	BYTE pField[MAXFIELD];

	//
	// Total number of messages
	//
	if(GetField(pData, pField, 0, MAXFIELD))
	{
		nTotalNumOfMsg = atoi((CHAR *)pField);

		//
		// Make sure that the nTotalNumOfMsg is valid. This is used to
		// calculate indexes into an array. I've seen corrept NMEA strings
		// with no checksum set this to large values.
		//
		if(nTotalNumOfMsg > 9 || nTotalNumOfMsg < 0) return; 
	}
	if(nTotalNumOfMsg < 1 || nTotalNumOfMsg*4 >= NP_MAX_CHAN)
	{
		return;
	}

	//
	// message number
	//
	if(GetField(pData, pField, 1, MAXFIELD))
	{
		nMsgNum = atoi((CHAR *)pField);

		//
		// Make sure that the message number is valid. This is used to
		// calculate indexes into an array
		//
		if(nMsgNum > 9 || nMsgNum < 0) return; 
	}

	//
	// Total satellites in view
	//
	if(GetField(pData, pField, 2, MAXFIELD))
	{
		m_wGSVTotalNumSatsInView = atoi((CHAR *)pField);
	}

	//
	// Satelite data
	//
	for(int i = 0; i < 4; i++)
	{
		// Satellite ID
		if(GetField(pData, pField, 3 + 4*i, MAXFIELD))
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wPRN = atoi((CHAR *)pField);
		}
		else
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wPRN = 0;
		}

		// Elevarion
		if(GetField(pData, pField, 4 + 4*i, MAXFIELD))
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wElevation = atoi((CHAR *)pField);
		}
		else
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wElevation = 0;
		}

		// Azimuth
		if(GetField(pData, pField, 5 + 4*i, MAXFIELD))
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wAzimuth = atoi((CHAR *)pField);
		}
		else
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wAzimuth = 0;
		}

		// SNR
		if(GetField(pData, pField, 6 + 4*i, MAXFIELD))
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wSignalQuality = atoi((CHAR *)pField);
		}
		else
		{
			m_GSVSatInfo[i+(nMsgNum-1)*4].m_wSignalQuality = 0;
		}

		//
		// Update "used in solution" (m_bUsedInSolution) flag. This is base
		// on the GSA message and is an added convenience for post processing
		//
		m_GSVSatInfo[i+(nMsgNum-1)*4].m_bUsedInSolution = IsSatUsedInSolution(m_GSVSatInfo[i+(nMsgNum-1)*4].m_wPRN);
	}

	m_dwGSVCount++;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void CNMEAParser::ProcessGPRMB(BYTE *pData)
{
	BYTE pField[MAXFIELD];

	//
	// Data status
	//
	if(GetField(pData, pField, 0, MAXFIELD))
	{
		m_btRMBDataStatus = pField[0];
	}
	else
	{
		m_btRMBDataStatus = 'V';
	}

	//
	// Cross track error
	//
	if(GetField(pData, pField, 1, MAXFIELD))
	{
		m_dRMBCrosstrackError = atof((CHAR *)pField);
	}
	else
	{
		m_dRMBCrosstrackError = 0.0;
	}

	//
	// Direction to steer
	//
	if(GetField(pData, pField, 2, MAXFIELD))
	{
		m_btRMBDirectionToSteer = pField[0];
	}
	else
	{
		m_btRMBDirectionToSteer = '?';
	}

	//
	// Orgin waypoint ID
	//
	if(GetField(pData, pField, 3, MAXFIELD))
	{
		strcpy(m_lpszRMBOriginWaypoint, (CHAR *)pField);
	}
	else
	{
		m_lpszRMBOriginWaypoint[0] = '\0';
	}

	//
	// Destination waypoint ID
	//
	if(GetField(pData, pField, 4, MAXFIELD))
	{
		strcpy(m_lpszRMBDestWaypoint, (CHAR *)pField);
	}
	else
	{
		m_lpszRMBDestWaypoint[0] = '\0';
	}

	//
	// Destination latitude
	//
	if(GetField(pData, pField, 5, MAXFIELD))
	{
		m_dRMBDestLatitude = atof((CHAR *)pField+2) / 60.0;
		pField[2] = '\0';
		m_dRMBDestLatitude += atof((CHAR *)pField);

	}
	if(GetField(pData, pField, 6, MAXFIELD))
	{
		if(pField[0] == 'S')
		{
			m_dRMBDestLatitude = -m_dRMBDestLatitude;
		}
	}

	//
	// Destination Longitude
	//
	if(GetField(pData, pField, 7, MAXFIELD))
	{
		m_dRMBDestLongitude = atof((CHAR *)pField+3) / 60.0;
		pField[3] = '\0';
		m_dRMBDestLongitude += atof((CHAR *)pField);
	}
	if(GetField(pData, pField, 8, MAXFIELD))
	{
		if(pField[0] == 'W')
		{
			m_dRMBDestLongitude = -m_dRMBDestLongitude;
		}
	}

	//
	// Range to destination nautical mi
	//
	if(GetField(pData, pField, 9, MAXFIELD))
	{
		m_dRMBRangeToDest = atof((CHAR *)pField);
	}
	else
	{
		m_dRMBCrosstrackError = 0.0;
	}

	//
	// Bearing to destination degrees true
	//
	if(GetField(pData, pField, 10, MAXFIELD))
	{
		m_dRMBBearingToDest = atof((CHAR *)pField);
	}
	else
	{
		m_dRMBBearingToDest = 0.0;
	}

	//
	// Closing velocity
	//
	if(GetField(pData, pField, 11, MAXFIELD))
	{
		m_dRMBDestClosingVelocity = atof((CHAR *)pField);
	}
	else
	{
		m_dRMBDestClosingVelocity = 0.0;
	}

	//
	// Arrival status
	//
	if(GetField(pData, pField, 12, MAXFIELD))
	{
		m_btRMBArrivalStatus = pField[0];
	}
	else
	{
		m_dRMBDestClosingVelocity = 'V';
	}

	m_dwRMBCount++;

}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void CNMEAParser::ProcessGPRMC(BYTE *pData)
{
	CHAR pBuff[10];
	BYTE pField[MAXFIELD];
	INT nStart;
	//
	// Time
	//
	if(GetField(pData, pField, 0, MAXFIELD))
	{
		// Hour
		pBuff[0] = pField[0];
		pBuff[1] = pField[1];
		pBuff[2] = '\0';
		m_btRMCHour = atoi(pBuff);

		// minute
		pBuff[0] = pField[2];
		pBuff[1] = pField[3];
		pBuff[2] = '\0';
		m_btRMCMinute = atoi(pBuff);

		// Second
		pBuff[0] = pField[4];
		pBuff[1] = pField[5];
		pBuff[2] = '\0';
		m_btRMCSecond = atoi(pBuff);
	}

	//
	// Data valid
	//
	if(GetField(pData, pField, 1, MAXFIELD))
	{
		m_btRMCDataValid = pField[0];
	}
	else
	{
		m_btRMCDataValid = 'V';
	}

	//
	// latitude
	//
	if(GetField(pData, pField, 2, MAXFIELD))
	{
		m_dRMCLatitude = atof((CHAR *)pField+2) / 60.0;
		pField[2] = '\0';
		m_dRMCLatitude += atof((CHAR *)pField);

	}
	if(GetField(pData, pField, 3, MAXFIELD))
	{
		if(pField[0] == 'S')
		{
			m_dRMCLatitude = -m_dRMCLatitude;
		}
	}

	//
	// Longitude
	//
	if(GetField(pData, pField, 4, MAXFIELD))
	{
		m_dRMCLongitude = atof((CHAR *)pField+3) / 60.0;
		pField[3] = '\0';
		m_dRMCLongitude += atof((CHAR *)pField);
	}
	if(GetField(pData, pField, 5, MAXFIELD))
	{
		if(pField[0] == 'W')
		{
			m_dRMCLongitude = -m_dRMCLongitude;
		}
	}

	//
	// Ground speed
	//
	if(GetField(pData, pField, 6, MAXFIELD))
	{
		m_dRMCGroundSpeed = atof((CHAR *)pField);
	}
	else
	{
		m_dRMCGroundSpeed = 0.0;
	}

	//
	// course over ground, degrees true
	//
	if(GetField(pData, pField, 7, MAXFIELD))
	{
		m_dRMCCourse = atof((CHAR *)pField);
	}
	else
	{
		m_dRMCCourse = 0.0;
	}

	//
	// Date
	//
	nStart = GetField(pData, pField, 8, MAXFIELD);
	if( nStart )
	{
		// Day
		pBuff[0] = pField[0];
		pBuff[1] = pField[1];
		pBuff[2] = '\0';
		m_btRMCDay = atoi(pBuff);

		// Month
		if ( m_bSimYear ) {
			pData[nStart+1] = '1';
			pData[nStart+2] = '2';
			pBuff[0] = '1';
			pBuff[1] = '2';
		}
		else {
			pBuff[0] = pField[2];
			pBuff[1] = pField[3];
		}
		pBuff[2] = '\0';
		m_btRMCMonth = atoi(pBuff);

		// Year (Only two digits. I wonder why?)
		pBuff[0] = pField[4];
		if ( m_bSimYear ) {
			pData[nStart+4] = '6';
			pBuff[1] = '6';
		}
		else pBuff[1] = pField[5];
		pBuff[2] = '\0';
		m_wRMCYear = atoi(pBuff);
		m_wRMCYear += 2000;				// make 4 digit date -- What assumptions should be made here?
	}



	//
	// course over ground, degrees true
	//
	if(GetField(pData, pField, 9, MAXFIELD))
	{
		m_dRMCMagVar = atof((CHAR *)pField);
	}
	else
	{
		m_dRMCMagVar = 0.0;
	}
	if(GetField(pData, pField, 10, MAXFIELD))
	{
		if(pField[0] == 'W')
		{
			m_dRMCMagVar = -m_dRMCMagVar;
		}
	}

	m_dwRMCCount++;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void CNMEAParser::ProcessGPZDA(BYTE *pData)
{
	CHAR pBuff[10];
	BYTE pField[MAXFIELD];

	//
	// Time
	//
	if(GetField(pData, pField, 0, MAXFIELD))
	{
		// Hour
		pBuff[0] = pField[0];
		pBuff[1] = pField[1];
		pBuff[2] = '\0';
		m_btZDAHour = atoi(pBuff);

		// minute
		pBuff[0] = pField[2];
		pBuff[1] = pField[3];
		pBuff[2] = '\0';
		m_btZDAMinute = atoi(pBuff);

		// Second
		pBuff[0] = pField[4];
		pBuff[1] = pField[5];
		pBuff[2] = '\0';
		m_btZDASecond = atoi(pBuff);
	}

	//
	// Day
	//
	if(GetField(pData, pField, 1, MAXFIELD))
	{
		m_btZDADay = atoi((CHAR *)pField);
	}
	else
	{
		m_btZDADay = 1;
	}

	//
	// Month
	//
	if(GetField(pData, pField, 2, MAXFIELD))
	{
		m_btZDAMonth = atoi((CHAR *)pField);
	}
	else
	{
		m_btZDAMonth = 1;
	}

	//
	// Year
	//
	if(GetField(pData, pField, 3, MAXFIELD))
	{
		m_wZDAYear = atoi((CHAR *)pField);
	}
	else
	{
		m_wZDAYear = 1;
	}

	//
	// Local zone hour
	//
	if(GetField(pData, pField, 4, MAXFIELD))
	{
		m_btZDALocalZoneHour = atoi((CHAR *)pField);
	}
	else
	{
		m_btZDALocalZoneHour = 0;
	}

	//
	// Local zone hour
	//
	if(GetField(pData, pField, 5, MAXFIELD))
	{
		m_btZDALocalZoneMinute = atoi((CHAR *)pField);
	}
	else
	{
		m_btZDALocalZoneMinute = 0;
	}

	m_dwZDACount++;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////