Merge pull request #42 from bmurray/master

Support for GNGNS Strings

Author: icholy

.travis.yml

@@ -5,18 +5,17 @@
 language: go
 
 go:
-    - 1.7.x
-    - 1.8.x
     - 1.9.x
     - 1.10.x
+    - 1.11.x
     - tip
 
 matrix:
     fast_finish: true
 
 before_install:
     - go get golang.org/x/tools/cmd/cover
-    - go get github.com/golang/lint/golint
+    - go get golang.org/x/lint/golint
     - go get github.com/mattn/goveralls
     - go get github.com/stretchr/testify/assert
 

README.md

@@ -28,6 +28,7 @@ At this moment, this library supports the following sentence types:
 - [GPZDA](http://aprs.gids.nl/nmea/#zda) - Date & time data
 - [PGRME](http://aprs.gids.nl/nmea/#rme) - Estimated Position Error (Garmin proprietary sentence)
 - [GPHDT](http://aprs.gids.nl/nmea/#hdt) - Actual vessel heading in degrees True
+- [GNGNS](https://www.trimble.com/oem_receiverhelp/v4.44/en/NMEA-0183messages_GNS.html) - Combined GPS fix for GPS, Glonass, Galileo, and BeiDou
 
 
 ## Example

gngns.go

@@ -0,0 +1,58 @@
+package nmea
+
+const (
+	// PrefixGNGNS prefix
+	PrefixGNGNS = "GNGNS"
+	// NoFixGNGNS Character
+	NoFixGNGNS = "N"
+	// AutonomousGNGNS Character
+	AutonomousGNGNS = "A"
+	// DifferentialGNGNS Character
+	DifferentialGNGNS = "D"
+	// PreciseGNGNS Character
+	PreciseGNGNS = "P"
+	// RealTimeKinematicGNGNS Character
+	RealTimeKinematicGNGNS = "R"
+	// FloatRTKGNGNS RealTime Kinematic Character
+	FloatRTKGNGNS = "F"
+	// EstimatedGNGNS Fix Character
+	EstimatedGNGNS = "E"
+	// ManualGNGNS Fix Character
+	ManualGNGNS = "M"
+	// SimulatorGNGNS Character
+	SimulatorGNGNS = "S"
+)
+
+// GNGNS is standard GNSS sentance that combined multiple constellations
+type GNGNS struct {
+	BaseSentence
+	Time       Time
+	Latitude   float64
+	Longitude  float64
+	Mode       []string
+	SVs        int64
+	HDOP       float64
+	Altitude   float64
+	Separation float64
+	Age        float64
+	Station    int64
+}
+
+// newGNGNS Constructor
+func newGNGNS(s BaseSentence) (GNGNS, error) {
+	p := newParser(s, PrefixGNGNS)
+	m := GNGNS{
+		BaseSentence: s,
+		Time:         p.Time(0, "time"),
+		Latitude:     p.LatLong(1, 2, "latitude"),
+		Longitude:    p.LatLong(3, 4, "longitude"),
+		Mode:         p.EnumChars(5, "mode", NoFixGNGNS, AutonomousGNGNS, DifferentialGNGNS, PreciseGNGNS, RealTimeKinematicGNGNS, FloatRTKGNGNS, EstimatedGNGNS, ManualGNGNS, SimulatorGNGNS),
+		SVs:          p.Int64(6, "SVs"),
+		HDOP:         p.Float64(7, "HDOP"),
+		Altitude:     p.Float64(8, "altitude"),
+		Separation:   p.Float64(9, "separation"),
+		Age:          p.Float64(10, "age"),
+		Station:      p.Int64(11, "station"),
+	}
+	return m, p.Err()
+}

gngns_test.go

@@ -0,0 +1,85 @@
+package nmea
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var gngnstests = []struct {
+	name string
+	raw  string
+	err  string
+	msg  GNGNS
+}{
+	{
+		name: "good sentence A",
+		raw:  "$GNGNS,014035.00,4332.69262,S,17235.48549,E,RR,13,0.9,25.63,11.24,,*70",
+		msg: GNGNS{
+			Time:       Time{true, 1, 40, 35, 0},
+			Latitude:   MustParseGPS("4332.69262 S"),
+			Longitude:  MustParseGPS("17235.48549 E"),
+			Mode:       []string{"R", "R"},
+			SVs:        13,
+			HDOP:       0.9,
+			Altitude:   25.63,
+			Separation: 11.24,
+			Age:        0,
+			Station:    0,
+		},
+	},
+	{
+		name: "good sentence B",
+		raw:  "$GNGNS,094821.0,4849.931307,N,00216.053323,E,AA,14,0.6,161.5,48.0,,*6D",
+		msg: GNGNS{
+			Time:       Time{true, 9, 48, 21, 0},
+			Latitude:   MustParseGPS("4849.931307 N"),
+			Longitude:  MustParseGPS("00216.053323 E"),
+			Mode:       []string{"A", "A"},
+			SVs:        14,
+			HDOP:       0.6,
+			Altitude:   161.5,
+			Separation: 48.0,
+			Age:        0,
+			Station:    0,
+		},
+	},
+	{
+		name: "good sentence B",
+		raw:  "$GNGNS,094821.0,4849.931307,N,00216.053323,E,AAN,14,0.6,161.5,48.0,,*23",
+		msg: GNGNS{
+			Time:       Time{true, 9, 48, 21, 0},
+			Latitude:   MustParseGPS("4849.931307 N"),
+			Longitude:  MustParseGPS("00216.053323 E"),
+			Mode:       []string{"A", "A", "N"},
+			SVs:        14,
+			HDOP:       0.6,
+			Altitude:   161.5,
+			Separation: 48.0,
+			Age:        0,
+			Station:    0,
+		},
+	},
+	{
+		name: "bad sentence",
+		raw:  "$GNGNS,094821.0,4849.931307,N,00216.053323,E,AAX,14,0.6,161.5,48.0,,*35",
+		err:  "nmea: GNGNS invalid mode: AAX",
+	},
+}
+
+func TestGNGNS(t *testing.T) {
+	for _, tt := range gngnstests {
+		t.Run(tt.name, func(t *testing.T) {
+			m, err := Parse(tt.raw)
+			if tt.err != "" {
+				assert.Error(t, err)
+				assert.EqualError(t, err, tt.err)
+			} else {
+				assert.NoError(t, err)
+				gngns := m.(GNGNS)
+				gngns.BaseSentence = BaseSentence{}
+				assert.Equal(t, tt.msg, gngns)
+			}
+		})
+	}
+}

gprmc_test.go

@@ -16,7 +16,7 @@ var gprmctests = []struct {
 		name: "good sentence A",
 		raw:  "$GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70",
 		msg: GPRMC{
-			Time:      Time{true, 22, 05, 16, 0},
+			Time:      Time{true, 22, 5, 16, 0},
 			Validity:  "A",
 			Speed:     173.8,
 			Course:    231.8,

parser.go

@@ -63,6 +63,32 @@ func (p *parser) EnumString(i int, context string, options ...string) string {
 	return ""
 }
 
+// EnumChars returns an array of strings that are matched in the Mode field.
+// It will only match the number of characters that are in the Mode field.
+// If the value is empty, it will return an empty array
+func (p *parser) EnumChars(i int, context string, options ...string) []string {
+	s := p.String(i, context)
+	if p.err != nil || s == "" {
+		return []string{}
+	}
+	strs := []string{}
+	for _, r := range s {
+		rs := string(r)
+		for _, o := range options {
+			if o == rs {
+				strs = append(strs, o)
+				break
+			}
+		}
+	}
+	if len(strs) != len(s) {
+
+		p.SetErr(context, s)
+		return []string{}
+	}
+	return strs
+}
+
 // Int64 returns the int64 value at the specified index.
 // If the value is an empty string, 0 is returned.
 func (p *parser) Int64(i int, context string) int64 {

parser_test.go

@@ -66,6 +66,33 @@ var parsertests = []struct {
 			return p.EnumString(1, "context", "a", "b")
 		},
 	},
+	{
+		name:     "EnumChars",
+		fields:   []string{"AA", "AB", "BA", "BB"},
+		expected: []string{"A", "B"},
+		parse: func(p *parser) interface{} {
+			return p.EnumChars(1, "context", "A", "B")
+		},
+	},
+	{
+		name:     "EnumChars invalid",
+		fields:   []string{"a", "AB", "c"},
+		expected: []string{},
+		hasErr:   true,
+		parse: func(p *parser) interface{} {
+			return p.EnumChars(1, "context", "X", "Y")
+		},
+	},
+	{
+		name:     "EnumChars with existing error",
+		fields:   []string{"a", "AB", "c"},
+		expected: []string{},
+		hasErr:   true,
+		parse: func(p *parser) interface{} {
+			p.SetErr("context", "value")
+			return p.EnumChars(1, "context", "A", "B")
+		},
+	},
 	{
 		name:     "Int64",
 		fields:   []string{"123"},

sentence.go

@@ -106,6 +106,8 @@ func Parse(raw string) (Sentence, error) {
 		return newGLGSV(s)
 	case PrefixGPHDT:
 		return newGPHDT(s)
+	case PrefixGNGNS:
+		return newGNGNS(s)
 	default:
 		return nil, fmt.Errorf("nmea: sentence type '%s' not implemented", s.Type)
 	}