/// <summary>
        /// Satellites used in the solution
        /// </summary>
        /// <returns>Array of Satellites</returns>
        public Satellite[] GetSatellitesInSolution()
        {
            Satellite[] inViewSatellites = GetSatellitesInView();
            ArrayList list = new ArrayList();
            for (int index = 0; index < dwSatelliteCount; index++)
            {
                Satellite found = null;
                for (int viewIndex = 0; viewIndex < inViewSatellites.Length && found == null; viewIndex++)
                {
                    if (rgdwSatellitesUsedPRNs[index] == inViewSatellites[viewIndex].Id)
                    {
                        found = inViewSatellites[viewIndex];
                        list.Add(found);
                    }
                }
            }

            return (Satellite[])list.ToArray(typeof(Satellite));
        }
        /// <summary>
        /// True if the SatellitesInSolution property is valid, false if invalid
        /// </summary>
        public bool SatellitesInSolutionValid
        {
            get { return (dwValidFields & GPS_VALID_SATELLITES_USED_PRNS) != 0; }
        }



        /// <summary>
        /// Satellites in view
        /// </summary>
        /// <returns>Array of Satellites</returns>
        public Satellite[] GetSatellitesInView()
        {
            Satellite[] satellites = null;
            if (dwSatellitesInView != 0)
            {
                satellites = new Satellite[dwSatellitesInView];
                for (int index = 0; index < satellites.Length; index++)
                {
                    satellites[index] = new Satellite();
                    satellites[index].Azimuth = rgdwSatellitesInViewAzimuth[index];
                    satellites[index].Elevation = rgdwSatellitesInViewElevation[index];
                    satellites[index].Id = rgdwSatellitesInViewPRNs[index];
                    satellites[index].SignalStrength = rgdwSatellitesInViewSignalToNoiseRatio[index];
                }
            }

            return satellites;
        }
        /// <summary>
        /// True if the SatellitesInView property is valid, false if invalid
        /// </summary>
        public bool SatellitesInViewValid
        {
            get { return (dwValidFields & GPS_VALID_SATELLITES_IN_VIEW) != 0; }
        }


        /// <summary>
        /// Number of satellites used in solution
        /// </summary>
        public int SatelliteCount
        {
            get { return dwSatelliteCount; }
        }
        /// <summary>
        /// True if the SatelliteCount property is valid, false if invalid
        /// </summary>
        public bool SatelliteCountValid
        {
            get { return (dwValidFields & GPS_VALID_SATELLITE_COUNT) != 0; }
        }

        /// <summary>
        /// Number of satellites in view.  
        /// </summary>
        public int SatellitesInViewCount
        {
            get { return dwSatellitesInView; }
        }
        /// <summary>
        /// True if the SatellitesInViewCount property is valid, false if invalid
        /// </summary>
        public bool SatellitesInViewCountValid
        {
            get { return (dwValidFields & GPS_VALID_SATELLITES_IN_VIEW) != 0; }
        }

        /// <summary>
        /// Speed in knots
        /// </summary>
        public float Speed
        {
            get { return flSpeed; }
        }
        /// <summary>
        /// True if the Speed property is valid, false if invalid
        /// </summary>
        public bool SpeedValid
        {
            get { return (dwValidFields & GPS_VALID_SPEED) != 0; }
        }

        /// <summary>
        /// Altitude with regards to ellipsoid, in meters
        /// </summary>
        public float EllipsoidAltitude
        {
            get { return flAltitudeWRTEllipsoid; }
        }
        /// <summary>
        /// True if the EllipsoidAltitude property is valid, false if invalid
        /// </summary>
        public bool EllipsoidAltitudeValid
        {
            get { return (dwValidFields & GPS_VALID_ALTITUDE_WRT_ELLIPSOID) != 0; }
        }

        /// <summary>
        /// Altitute with regards to sea level, in meters
        /// </summary>
        public float SeaLevelAltitude
        {
            get { return flAltitudeWRTSeaLevel; }
        }
        /// <summary>
        /// True if the SeaLevelAltitude property is valid, false if invalid
        /// </summary>
        public bool SeaLevelAltitudeValid
        {
            get { return (dwValidFields & GPS_VALID_ALTITUDE_WRT_SEA_LEVEL) != 0; }
        }

        /// <summary>
        /// Latitude in decimal degrees.  North is positive
        /// </summary>
        public double Latitude
        {
            get { return ParseDegreesMinutesSeconds(dblLatitude).ToDecimalDegrees(); }
        }
        /// <summary>
        /// Latitude in degrees, minutes, seconds.  North is positive
        /// </summary>
        public DegreesMinutesSeconds LatitudeInDegreesMinutesSeconds
        {
            get { return ParseDegreesMinutesSeconds(dblLatitude); }
        }

        /// <summary>
        /// True if the Latitude property is valid, false if invalid
        /// </summary>
        public bool LatitudeValid
        {
            get { return (dwValidFields & GPS_VALID_LATITUDE) != 0; }
        }

        /// <summary>
        /// Longitude in decimal degrees.  East is positive
        /// </summary>
        public double Longitude
        {
            get { return ParseDegreesMinutesSeconds(dblLongitude).ToDecimalDegrees(); }
        }

        /// <summary>
        /// Longitude in degrees, minutes, seconds.  East is positive
        /// </summary>
        public DegreesMinutesSeconds LongitudeInDegreesMinutesSeconds
        {
            get { return ParseDegreesMinutesSeconds(dblLongitude); }
        }
        /// <summary>
        /// True if the Longitude property is valid, false if invalid
        /// </summary>
        public bool LongitudeValid
        {
            get { return (dwValidFields & GPS_VALID_LONGITUDE) != 0; }
        }

        /// <summary>
        /// Degrees heading (course made good).  True North=0
        /// </summary>
        public float Heading
        {
            get { return flHeading; }
        }
        /// <summary>
        /// True if the Heading property is valid, false if invalid
        /// </summary>
        public bool HeadingValid
        {
            get { return (dwValidFields & GPS_VALID_HEADING) != 0; }
        }

        /// <summary>
        /// Position Dilution Of Precision
        /// </summary>
        public float PositionDilutionOfPrecision
        {
            get { return flPositionDilutionOfPrecision; }
        }
        /// <summary>
        /// True if the PositionDilutionOfPrecision property is valid, false if invalid
        /// </summary>
        public bool PositionDilutionOfPrecisionValid
        {
            get { return (dwValidFields & GPS_VALID_POSITION_DILUTION_OF_PRECISION) != 0; }
        }

        /// <summary>
        /// Horizontal Dilution Of Precision
        /// </summary>
        public float HorizontalDilutionOfPrecision
        {
            get { return flHorizontalDilutionOfPrecision; }
        }
        /// <summary>
        /// True if the HorizontalDilutionOfPrecision property is valid, false if invalid
        /// </summary>
        public bool HorizontalDilutionOfPrecisionValid
        {
            get { return (dwValidFields & GPS_VALID_HORIZONTAL_DILUTION_OF_PRECISION) != 0; }
        }

        /// <summary>
        /// Vertical Dilution Of Precision
        /// </summary>
        public float VerticalDilutionOfPrecision
        {
            get { return flVerticalDilutionOfPrecision; }
        }
        /// <summary>
        /// True if the VerticalDilutionOfPrecision property is valid, false if invalid
        /// </summary>
        public bool VerticalDilutionOfPrecisionValid
        {
            get { return (dwValidFields & GPS_VALID_VERTICAL_DILUTION_OF_PRECISION) != 0; }
        }

        /// <summary>
        /// Parses out the degrees, minutes, seconds from the double format returned by
        /// the NMEA GPS device
        /// </summary>
        /// <param name="val">degrees, minutes, seconds as a double</param>
        /// <returns>DegreesMinutesSeconds structure</returns>
        private DegreesMinutesSeconds ParseDegreesMinutesSeconds(double val)
        {
            double degrees = (val / 100.0);
            double minutes = (Math.Abs(degrees) - Math.Abs((double)(int)(degrees))) * 100;
            double seconds = (Math.Abs(val) - Math.Abs((double)(int)val)) * 60.0;

            return new DegreesMinutesSeconds((int)degrees, (int)minutes, seconds);
        }
    }

}