bool RMB::Parse( const SENTENCE& sentence )
{
/*
** RMB - Recommended Minimum Navigation Information
** 14
** 1 2 3 4 5 6 7 8 9 10 11 12 13|
** | | | | | | | | | | | | | |
** $--RMB,A,x.x,a,c--c,c--c,llll.ll,a,yyyyy.yy,a,x.x,x.x,x.x,A*hh<CR><LF>
**
** Field Number:
** 1) Status, V = Navigation receiver warning
** 2) Cross Track error - nautical miles
** 3) Direction to Steer, Left or Right
** 4) TO Waypoint ID
** 5) FROM Waypoint ID
** 6) Destination Waypoint Latitude
** 7) N or S
** 8) Destination Waypoint Longitude
** 9) E or W
** 10) Range to destination in nautical miles
** 11) Bearing to destination in degrees True
** 12) Destination closing velocity in knots
** 13) Arrival Status, A = Arrival Circle Entered
** 14) Checksum
*/
/*
** First we check the checksum...
*/
NMEA0183_BOOLEAN check = sentence.IsChecksumBad( 14 );
if ( check == NTrue )
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
/*
if ( check == Unknown0183 )
{
SetErrorMessage( _T("Missing Checksum") );
return( FALSE );
}
*/
IsDataValid = sentence.Boolean( 1 );
CrossTrackError = sentence.Double( 2 );
DirectionToSteer = sentence.LeftOrRight( 3 );
From = sentence.Field( 4 );
To = sentence.Field( 5 );
DestinationPosition.Parse( 6, 7, 8, 9, sentence );
RangeToDestinationNauticalMiles = sentence.Double( 10 );
BearingToDestinationDegreesTrue = sentence.Double( 11 );
DestinationClosingVelocityKnots = sentence.Double( 12 );
IsArrivalCircleEntered = sentence.Boolean( 13 );
return( TRUE );
}
BOOL RMA::Parse( const SENTENCE& sentence )
{
ASSERT_VALID( this );
/*
** RMA - Recommended Minimum Navigation Information
** 12
** 1 2 3 4 5 6 7 8 9 10 11|
** | | | | | | | | | | | |
** $--RMA,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,x.x,x.x,x.x,a*hh<CR><LF>
**
** Field Number:
** 1) Blink Warning
** 2) Latitude
** 3) N or S
** 4) Longitude
** 5) E or W
** 6) Time Difference A, uS
** 7) Time Difference B, uS
** 8) Speed Over Ground, Knots
** 9) Track Made Good, degrees true
** 10) Magnetic Variation, degrees
** 11) E or W
** 12) Checksum
*/
/*
** First we check the checksum...
*/
NMEA0183_BOOLEAN check = sentence.IsChecksumBad( 12 );
if ( check == True )
{
SetErrorMessage( "Invalid Checksum" );
return( FALSE );
}
if ( check == Unknown )
{
SetErrorMessage( "Missing Checksum" );
return( FALSE );
}
IsDataValid = sentence.Boolean( 1 );
Position.Parse( 2, 3, 4, 5, sentence );
TimeDifferenceA = sentence.Double( 6 );
TimeDifferenceB = sentence.Double( 7 );
SpeedOverGroundKnots = sentence.Double( 8 );
TrackMadeGoodDegreesTrue = sentence.Double( 9 );
MagneticVariation = sentence.Double( 10 );
MagneticVariationDirection = sentence.EastOrWest( 11 );
return( TRUE );
}
bool XTE::Parse( const SENTENCE& sentence )
{
// ASSERT_VALID( this );
wxString field_data;
/*
** XTE - Autopilot Sentence
**
** 1 2 3 4 5 6
** | | | | | |
** $--XTE,A,A,x.x,a,N*hh<CR><LF>
**
** 1) Status
** V = LORAN-C Blink or SNR warning
** V = general warning flag or other navigation systems when a reliable
** fix is not available
** 2) Status
** V = Loran-C Cycle Lock warning flag
** A = OK or not used
** 3) Cross Track Error Magnitude
** 4) Direction to steer, L or R
** 5) Cross Track Units, N = Nautical Miles
** 6) Checksum
*/
/*
** First we check the checksum...
*/
NMEA0183_BOOLEAN check = sentence.IsChecksumBad( 15 );
if ( check == NTrue )
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
/*
** Line has already been checked for checksum validity
*/
IsLoranBlinkOK = sentence.Boolean( 1 );
IsLoranCCycleLockOK = sentence.Boolean( 2 );
CrossTrackErrorDistance = sentence.Double( 3 );
DirectionToSteer = sentence.LeftOrRight( 4 );
CrossTrackUnits = sentence.Field( 5 );
return( TRUE );
}
bool RSA::Parse( const SENTENCE& sentence )
{
// ASSERT_VALID( this );
/*
** RSA - Rudder Sensor Angle
**
** 1 2 3 4 5
** | | | | |
** $--RSA,x.x,A,x.x,A*hh<CR><LF>
**
** Field Number:
** 1) Starboard (or single) rudder sensor, "-" means Turn To Port
** 2) Status, A means data is valid
** 3) Port rudder sensor
** 4) Status, A means data is valid
** 5) Checksum
*/
/*
** First we check the checksum...
*/
if ( sentence.IsChecksumBad( 5 ) == TRUE )
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
Starboard = sentence.Double( 1 );
IsStarboardDataValid = sentence.Boolean( 2 );
Port = sentence.Double( 3 );
IsPortDataValid = sentence.Boolean( 4 );
return( TRUE );
}
bool TRF::Parse( const SENTENCE& sentence )
{
/*
** TRF - TRANSIT Fix Data
** 13
** 1 2 3 4 5 6 7 8 9 10 11 12|
** | | | | | | | | | | | | |
** $--TRF,hhmmss.ss,xxxxxx,llll.ll,a,yyyyy.yy,a,x.x,x.x,x.x,x.x,xxx,A*hh<CR><LF>
**
** Field Number:
** 1) UTC Time
** 2) Date, ddmmyy
** 3) Latitude
** 4) N or S
** 5) Longitude
** 6) E or W
** 7) Elevation Angle
** 8) Number of iterations
** 9) Number of Doppler intervals
** 10) Update distance, nautical miles
** 11) Satellite ID
** 12) Data Validity
** 13) Checksum
*/
/*
** First we check the checksum...
*/
if ( sentence.IsChecksumBad( 13 ) == True )
{
SetErrorMessage( "Invalid Checksum" );
return( false );
}
UTCTime = sentence.Field( 1 );
Time = sentence.Time( 1 );
Date = sentence.Field( 2 );
Position.Parse( 3, 4, 5, 6, sentence );
ElevationAngle = sentence.Double( 7 );
NumberOfIterations = sentence.Double( 8 );
NumberOfDopplerIntervals = sentence.Double( 9 );
UpdateDistanceNauticalMiles = sentence.Double( 10 );
SatelliteID = sentence.Integer( 11 );
IsDataValid = sentence.Boolean( 12 );
return( true );
}
bool MWV::Parse( const SENTENCE& sentence )
{
// ASSERT_VALID( this );
/*
** MWV - Wind Speed and Angle
**
** 1 2 3 4 5
** | | | | |
** $--MWV,x.x,a,x.x,a*hh<CR><LF>
**
** Field Number:
** 1) Wind Angle, 0 to 360 degrees
** 2) Reference, R = Relative, T = True
** 3) Wind Speed
** 4) Wind Speed Units, K/M/N
** 5) Status, A = Data Valid
** 6) Checksum
*/
/*
** First we check the checksum...
*/
if ( sentence.IsChecksumBad( 6 ) == TRUE )
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
WindAngle = sentence.Double( 1 );
Reference = sentence.Field( 2 );
WindSpeed = sentence.Double( 3 );
WindSpeedUnits = sentence.Field( 4 );
IsDataValid = sentence.Boolean( 5 );
return( TRUE );
}
bool RPM::Parse( const SENTENCE& sentence )
{
/*
** RPM - Revolutions
**
** 1 2 3 4 5 6
** | | | | | |
** $--RPM,a,x,x.x,x.x,A*hh<CR><LF>
**
** Field Number:
** 1) Sourse, S = Shaft, E = Engine
** 2) Engine or shaft number
** 3) Speed, Revolutions per minute
** 4) Propeller pitch, % of maximum, "-" means astern
** 5) Status, A means data is valid
** 6) Checksum
*/
/*
** First we check the checksum...
*/
if ( sentence.IsChecksumBad( 6 ) == True )
{
SetErrorMessage( "Invalid Checksum" );
return( false );
}
Source = sentence.Field( 1 );
SourceNumber = sentence.Integer( 2 );
RevolutionsPerMinute = sentence.Double( 3 );
PropellerPitchPercentage = sentence.Double( 4 );
IsDataValid = sentence.Boolean( 5 );
return( true );
}
bool GLL::Parse( const SENTENCE& sentence )
{
// ASSERT_VALID( this );
/*
** GLL - Geographic Position - Latitude/Longitude
** Latitude, N/S, Longitude, E/W, UTC, Status
**
** +-------------------------------- 1) Latitude
** | +------------------------ 2) N or S (North or South)
** | | +---------------------- 3) Longitude
** | | | +------------- 4) E or W (East or West)
** | | | | +----------- 5) Universal Time Coordinated (UTC)
** | | | | | +- 6) Status A - Data Valid, V - Data Invalid
** | | | | | | +7) Checksum
** $--GLL,llll.ll,a,yyyyy.yy,a,hhmmss.ss,A*hh<CR><LF>
*/
/*
** First we check the checksum...
*/
int target_field_count = 6;
NMEA0183_BOOLEAN check = sentence.IsChecksumBad( 7 );
if ( check == NTrue )
{
/*
** This may be an NMEA Version 2.3 sentence, with "Mode" field
*/
wxString checksum_in_sentence = sentence.Field( 7 );
if(checksum_in_sentence.StartsWith(_T("*"))) // Field is a valid erroneous checksum
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
else
{
target_field_count = 7;
check = sentence.IsChecksumBad( 8 );
if( check == NTrue)
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
}
}
if ( sentence.GetNumberOfDataFields() == target_field_count )
{
Position.Parse( 1, 2, 3, 4, sentence );
UTCTime = sentence.Field( 5 );
IsDataValid = sentence.Boolean( 6 );
return( TRUE );
}
// May be old style GLL sentence
if ( sentence.GetNumberOfDataFields() == 4 )
{
Position.Parse( 1, 2, 3, 4, sentence );
IsDataValid = NTrue;
return( TRUE );
}
// A real error...
SetErrorMessage( _T("Invalid FieldCount") );
return( FALSE );
}
bool RMC::Parse( const SENTENCE& sentence )
{
// ASSERT_VALID( this );
/*
** RMC - Recommended Minimum Navigation Information
**
** Version 2.0 Format
** 12
** 1 2 3 4 5 6 7 8 9 10 11|
** | | | | | | | | | | | |
** $--RMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,xxxx,x.x,a*hh<CR><LF>
**
** Field Number:
** 1) UTC Time
** 2) Status, V = Navigation receiver warning
** 3) Latitude
** 4) N or S
** 5) Longitude
** 6) E or W
** 7) Speed over ground, knots
** 8) Track made good, degrees true
** 9) Date, ddmmyy
** 10) Magnetic Variation, degrees
** 11) E or W
** Version 2.0
** 12) Checksum
** Version 2.3
** 12) Mode (D or A), optional, may be NULL
** 13) Checksum
*/
/*
** First we check the checksum...
*/
NMEA0183_BOOLEAN check = sentence.IsChecksumBad( 12 );
if ( check == NTrue )
{
/*
** This may be an NMEA Version 2.3 sentence, with "Mode" field
*/
wxString checksum_in_sentence = sentence.Field( 12 );
if(checksum_in_sentence.StartsWith(_T("*"))) // Field is a valid erroneous checksum
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
else
{
check = sentence.IsChecksumBad( 13 );
if( check == NTrue)
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
}
}
/*
if ( check == Unknown0183 )
{
SetErrorMessage( _T("Missing Checksum") );
return( FALSE );
}
*/
UTCTime = sentence.Field( 1 );
IsDataValid = sentence.Boolean( 2 );
Position.Parse( 3, 4, 5, 6, sentence );
SpeedOverGroundKnots = sentence.Double( 7 );
TrackMadeGoodDegreesTrue = sentence.Double( 8 );
Date = sentence.Field( 9 );
MagneticVariation = sentence.Double( 10 );
MagneticVariationDirection = sentence.EastOrWest( 11 );
return( TRUE );
}
void LINE_OF_POSITION::Parse( int first_field_number, const SENTENCE& sentence )
{
ZoneID = sentence.Field( first_field_number );
LineOfPosition = sentence.Double( first_field_number + 1 );
MasterLine = sentence.Boolean( first_field_number + 2 );
}
bool APB::Parse( const SENTENCE& sentence )
{
// ASSERT_VALID( this );
wxString field_data;
/*
** APB - Autopilot Sentence "B"
** 13 15
** 1 2 3 4 5 6 7 8 9 10 11 12| 14|
** | | | | | | | | | | | | | | |
** $--APB,A,A,x.x,a,N,A,A,x.x,a,c--c,x.x,a,x.x,a*hh<CR><LF>
**
** 1) Status
** V = LORAN-C Blink or SNR warning
** V = general warning flag or other navigation systems when a reliable
** fix is not available
** 2) Status
** V = Loran-C Cycle Lock warning flag
** A = OK or not used
** 3) Cross Track Error Magnitude
** 4) Direction to steer, L or R
** 5) Cross Track Units, N = Nautical Miles
** 6) Status
** A = Arrival Circle Entered
** 7) Status
** A = Perpendicular passed at waypoint
** 8) Bearing origin to destination
** 9) M = Magnetic, T = True
** 10) Destination Waypoint ID
** 11) Bearing, present position to Destination
** 12) M = Magnetic, T = True
** 13) Heading to steer to destination waypoint
** 14) M = Magnetic, T = True
** 15) Checksum
*/
/*
** First we check the checksum...
*/
NMEA0183_BOOLEAN check = sentence.IsChecksumBad( 15 );
if ( check == NTrue )
{
SetErrorMessage( _T("Invalid Checksum") );
return( FALSE );
}
/*
** Line has already been checked for checksum validity
*/
IsLoranBlinkOK = sentence.Boolean( 1 );
IsLoranCCycleLockOK = sentence.Boolean( 2 );
CrossTrackErrorMagnitude = sentence.Double( 3 );
DirectionToSteer = sentence.LeftOrRight( 4 );
CrossTrackUnits = sentence.Field( 5 );
IsArrivalCircleEntered = sentence.Boolean( 6 );
IsPerpendicular = sentence.Boolean( 7 );
BearingOriginToDestination = sentence.Double( 8 );
BearingOriginToDestinationUnits = sentence.Field( 9 );
To = sentence.Field( 10 );
BearingPresentPositionToDestination = sentence.Double( 11 );
BearingPresentPositionToDestinationUnits = sentence.Field( 12 );
HeadingToSteer = sentence.Double( 13 );
HeadingToSteerUnits = sentence.Field( 14 );
return( TRUE );
}
