MiPad4/android_device_xiaomi_sdm660-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Enhance LocationAPI structs to hold full position"

Browse source
This commit is contained in:
Linux Build Service Account 2018-02-27 02:49:59 -08:00 committed by Gerrit - the friendly Code Review server
commit 25bf85b355
5 changed files with 279 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
core/LocApiBase.cpp
View file

@ -236,7 +236,7 @@ void LocApiBase::reportPosition(UlpLocation& location,
// print the location info before delivering
LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
"altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
"timestamp: %" PRId64 "\n rawDataSize: %d\n rawData: %p\n "
"timestamp: %" PRId64 "\n"
"Session status: %d\n Technology mask: %u\n "
"SV used in fix (gps/glo/bds/gal/qzss) : \
(%" PRIx64 "/%" PRIx64 "/%" PRIx64 "/%" PRIx64 "/%" PRIx64 ")",
@ -244,8 +244,7 @@ void LocApiBase::reportPosition(UlpLocation& location,
location.gpsLocation.latitude, location.gpsLocation.longitude,
location.gpsLocation.altitude, location.gpsLocation.speed,
location.gpsLocation.bearing, location.gpsLocation.accuracy,
location.gpsLocation.timestamp, location.rawDataSize,
location.rawData, status, loc_technology_mask,
location.gpsLocation.timestamp, status, loc_technology_mask,
locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask,
locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask,
locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask,

101
gnss/GnssAdapter.cpp
View file

@ -190,32 +190,32 @@ GnssAdapter::convertOptions(LocPosMode& out, const LocationOptions& options)
}
void
GnssAdapter::convertLocation(Location& out, const LocGpsLocation& locGpsLocation,
GnssAdapter::convertLocation(Location& out, const UlpLocation& ulpLocation,
const GpsLocationExtended& locationExtended,
const LocPosTechMask techMask)
{
memset(&out, 0, sizeof(Location));
out.size = sizeof(Location);
if (LOC_GPS_LOCATION_HAS_LAT_LONG & locGpsLocation.flags) {
if (LOC_GPS_LOCATION_HAS_LAT_LONG & ulpLocation.gpsLocation.flags) {
out.flags |= LOCATION_HAS_LAT_LONG_BIT;
out.latitude = locGpsLocation.latitude;
out.longitude = locGpsLocation.longitude;
out.latitude = ulpLocation.gpsLocation.latitude;
out.longitude = ulpLocation.gpsLocation.longitude;
}
if (LOC_GPS_LOCATION_HAS_ALTITUDE & locGpsLocation.flags) {
if (LOC_GPS_LOCATION_HAS_ALTITUDE & ulpLocation.gpsLocation.flags) {
out.flags |= LOCATION_HAS_ALTITUDE_BIT;
out.altitude = locGpsLocation.altitude;
out.altitude = ulpLocation.gpsLocation.altitude;
}
if (LOC_GPS_LOCATION_HAS_SPEED & locGpsLocation.flags) {
if (LOC_GPS_LOCATION_HAS_SPEED & ulpLocation.gpsLocation.flags) {
out.flags |= LOCATION_HAS_SPEED_BIT;
out.speed = locGpsLocation.speed;
out.speed = ulpLocation.gpsLocation.speed;
}
if (LOC_GPS_LOCATION_HAS_BEARING & locGpsLocation.flags) {
if (LOC_GPS_LOCATION_HAS_BEARING & ulpLocation.gpsLocation.flags) {
out.flags |= LOCATION_HAS_BEARING_BIT;
out.bearing = locGpsLocation.bearing;
out.bearing = ulpLocation.gpsLocation.bearing;
}
if (LOC_GPS_LOCATION_HAS_ACCURACY & locGpsLocation.flags) {
if (LOC_GPS_LOCATION_HAS_ACCURACY & ulpLocation.gpsLocation.flags) {
out.flags |= LOCATION_HAS_ACCURACY_BIT;
out.accuracy = locGpsLocation.accuracy;
out.accuracy = ulpLocation.gpsLocation.accuracy;
}
if (GPS_LOCATION_EXTENDED_HAS_VERT_UNC & locationExtended.flags) {
out.flags |= LOCATION_HAS_VERTICAL_ACCURACY_BIT;
@ -229,7 +229,7 @@ GnssAdapter::convertLocation(Location& out, const LocGpsLocation& locGpsLocation
out.flags |= LOCATION_HAS_BEARING_ACCURACY_BIT;
out.bearingAccuracy = locationExtended.bearing_unc;
}
out.timestamp = locGpsLocation.timestamp;
out.timestamp = ulpLocation.gpsLocation.timestamp;
if (LOC_POS_TECH_MASK_SATELLITE & techMask) {
out.techMask |= LOCATION_TECHNOLOGY_GNSS_BIT;
}
@ -259,6 +259,11 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out,
out.hdop = locationExtended.hdop;
out.vdop = locationExtended.vdop;
}
if (GPS_LOCATION_EXTENDED_HAS_EXT_DOP & locationExtended.flags) {
out.flags |= GNSS_LOCATION_INFO_EXT_DOP_BIT;
out.gdop = locationExtended.extDOP.GDOP;
out.tdop = locationExtended.extDOP.TDOP;
}
if (GPS_LOCATION_EXTENDED_HAS_MAG_DEV & locationExtended.flags) {
out.flags |= GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT;
out.magneticDeviation = locationExtended.magneticDeviation;
@ -315,6 +320,53 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out,
out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT;
out.horUncEllipseOrientAzimuth = locationExtended.horUncEllipseOrientAzimuth;
}
if (GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA & locationExtended.flags) {
out.flags |= GNSS_LOCATION_INFO_GNSS_SV_USED_DATA_BIT;
out.svUsedInPosition.gpsSvUsedIdsMask =
locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask;
out.svUsedInPosition.gloSvUsedIdsMask =
locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask;
out.svUsedInPosition.galSvUsedIdsMask =
locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask;
out.svUsedInPosition.bdsSvUsedIdsMask =
locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask;
out.svUsedInPosition.qzssSvUsedIdsMask =
locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask;
}
if (GPS_LOCATION_EXTENDED_HAS_NAV_SOLUTION_MASK & locationExtended.flags) {
out.flags |= GNSS_LOCATION_INFO_NAV_SOLUTION_MASK_BIT;
out.navSolutionMask = locationExtended.navSolutionMask;
}
if (GPS_LOCATION_EXTENDED_HAS_POS_TECH_MASK & locationExtended.flags) {
out.flags |= GPS_LOCATION_EXTENDED_HAS_POS_TECH_MASK;
out.posTechMask = locationExtended.tech_mask;
}
if (GPS_LOCATION_EXTENDED_HAS_POS_DYNAMICS_DATA & locationExtended.flags) {
out.flags |= GPS_LOCATION_EXTENDED_HAS_POS_DYNAMICS_DATA;
if (locationExtended.bodyFrameData.bodyFrameDatamask &
LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT) {
out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT;
}
if (locationExtended.bodyFrameData.bodyFrameDatamask &
LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT) {
out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT;
}
if (locationExtended.bodyFrameData.bodyFrameDatamask &
LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT) {
out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT;
}
if (locationExtended.bodyFrameData.bodyFrameDatamask & LOCATION_NAV_DATA_HAS_YAW_RATE_BIT) {
out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_YAW_RATE_BIT;
}
if (locationExtended.bodyFrameData.bodyFrameDatamask & LOCATION_NAV_DATA_HAS_PITCH_BIT) {
out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_PITCH_BIT;
}
out.bodyFrameData.longAccel = locationExtended.bodyFrameData.longAccel;
out.bodyFrameData.latAccel = locationExtended.bodyFrameData.latAccel;
out.bodyFrameData.vertAccel = locationExtended.bodyFrameData.vertAccel;
out.bodyFrameData.yawRate = locationExtended.bodyFrameData.yawRate;
out.bodyFrameData.pitch = locationExtended.bodyFrameData.pitch;
}
}
inline uint32_t
@ -1151,7 +1203,7 @@ GnssAdapter::updateClientsEventMask()
{
LOC_API_ADAPTER_EVENT_MASK_T mask = 0;
for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
if (it->second.trackingCb != nullptr) {
if (it->second.trackingCb != nullptr || it->second.gnssLocationInfoCb != nullptr) {
mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT;
}
if (it->second.gnssNiCb != nullptr) {
@ -1340,7 +1392,7 @@ bool
GnssAdapter::hasTrackingCallback(LocationAPI* client)
{
auto it = mClientData.find(client);
return (it != mClientData.end() && it->second.trackingCb);
return (it != mClientData.end() && (it->second.trackingCb || it->second.gnssLocationInfoCb));
}
bool
@ -2126,15 +2178,15 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids;
}
for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
if (nullptr != it->second.trackingCb) {
Location location = {};
convertLocation(location, ulpLocation.gpsLocation, locationExtended, techMask);
it->second.trackingCb(location);
}
if (nullptr != it->second.gnssLocationInfoCb) {
GnssLocationInfoNotification locationInfo = {};
convertLocationInfo(locationInfo, locationExtended);
convertLocation(locationInfo.location, ulpLocation, locationExtended, techMask);
it->second.gnssLocationInfoCb(locationInfo);
} else if (nullptr != it->second.trackingCb) {
Location location = {};
convertLocation(location, ulpLocation, locationExtended, techMask);
it->second.trackingCb(location);
}
}
}
@ -2152,15 +2204,6 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
reportNmea(sentence.c_str(), sentence.length());
}
}
// Free the allocated memory for rawData
UlpLocation* gp = (UlpLocation*)&(ulpLocation);
if (gp != NULL && gp->rawData != NULL)
{
delete (char*)gp->rawData;
gp->rawData = NULL;
gp->rawDataSize = 0;
}
}
void

2
gnss/GnssAdapter.h
View file

@ -119,7 +119,7 @@ class GnssAdapter : public LocAdapterBase {
/*==== CONVERSION ===================================================================*/
static void convertOptions(LocPosMode& out, const LocationOptions& options);
static void convertLocation(Location& out, const LocGpsLocation& locGpsLocation,
static void convertLocation(Location& out, const UlpLocation& ulpLocation,
const GpsLocationExtended& locationExtended,
const LocPosTechMask techMask);
static void convertLocationInfo(GnssLocationInfoNotification& out,

205
location/LocationAPI.h
View file

@ -88,6 +88,40 @@ typedef enum {
LOCATION_RELIABILITY_HIGH,
} LocationReliability;
typedef uint32_t GnssLocationNavSolutionMask;
typedef enum {
LOCATION_SBAS_CORRECTION_IONO_BIT = (1<<0), // SBAS ionospheric correction is used
LOCATION_SBAS_CORRECTION_FAST_BIT = (1<<1), // SBAS fast correction is used
LOCATION_SBAS_CORRECTION_LONG_BIT = (1<<2), // SBAS long-tem correction is used
LOCATION_SBAS_INTEGRITY_BIT = (1<<3), // SBAS integrity information is used
LOCATION_NAV_CORRECTION_DGNSS_BIT = (1<<4), // Position Report is DGNSS corrected
LOCATION_NAV_CORRECTION_RTK_BIT = (1<<5), // Position Report is RTK corrected
LOCATION_NAV_CORRECTION_PPP_BIT = (1<<6) // Position Report is PPP corrected
} GnssLocationNavSolutionBits;
typedef uint32_t GnssLocationPosTechMask;
typedef enum {
LOCATION_POS_TECH_DEFAULT_BIT = 0,
LOCATION_POS_TECH_SATELLITE_BIT = (1<<0),
LOCATION_POS_TECH_CELLID_BIT = (1<<1),
LOCATION_POS_TECH_WIFI_BIT = (1<<2),
LOCATION_POS_TECH_SENSORS_BIT = (1<<3),
LOCATION_POS_TECH_REFERENCE_LOCATION_BIT = (1<<4),
LOCATION_POS_TECH_INJECTED_COARSE_POSITION_BIT = (1<<5),
LOCATION_POS_TECH_AFLT_BIT = (1<<6),
LOCATION_POS_TECH_HYBRID_BIT = (1<<7),
LOCATION_POS_TECH_PPE_BIT = (1<<8)
} GnssLocationPosTechBits;
typedef uint32_t GnssLocationPosDataMask;
typedef enum {
LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT = (1<<0), // Navigation data has Forward Acceleration
LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT = (1<<1), // Navigation data has Sideward Acceleration
LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT = (1<<2), // Navigation data has Vertical Acceleration
LOCATION_NAV_DATA_HAS_YAW_RATE_BIT = (1<<3), // Navigation data has Heading Rate
LOCATION_NAV_DATA_HAS_PITCH_BIT = (1<<4) // Navigation data has Body pitch
} GnssLocationPosDataBits;
typedef uint32_t GnssLocationInfoFlagMask;
typedef enum {
GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT = (1<<0), // valid altitude mean sea level
@ -97,7 +131,14 @@ typedef enum {
GNSS_LOCATION_INFO_VER_RELIABILITY_BIT = (1<<4), // valid vertical reliability
GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT = (1<<5), // valid elipsode semi major
GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT = (1<<6), // valid elipsode semi minor
GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT = (1<<7),// valid accuracy elipsode azimuth
GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT = (1<<7), // valid accuracy elipsode azimuth
GNSS_LOCATION_INFO_GNSS_SV_USED_DATA_BIT = (1<<8), // valid gnss sv used in pos data
GNSS_LOCATION_INFO_NAV_SOLUTION_MASK_BIT = (1<<9), // valid navSolutionMask
GNSS_LOCATION_INFO_POS_TECH_MASK_BIT = (1<<10),// valid LocPosTechMask
GNSS_LOCATION_INFO_SV_SOURCE_INFO_BIT = (1<<11),// valid LocSvInfoSource
GNSS_LOCATION_INFO_POS_DYNAMICS_DATA_BIT = (1<<12),// valid position dynamics data
GNSS_LOCATION_INFO_GPS_TIME_BIT = (1<<13),// valid GPS Time
GNSS_LOCATION_INFO_EXT_DOP_BIT = (1<<14) // valid gdop, tdop
} GnssLocationInfoFlagBits;
typedef enum {
@ -411,6 +452,45 @@ typedef enum {
GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT = (1<<4),
} GnssAidingDataSvTypeBits;
typedef enum
{
GNSS_LOC_SV_SYSTEM_GPS = 1,
/**< GPS satellite. */
GNSS_LOC_SV_SYSTEM_GALILEO = 2,
/**< GALILEO satellite. */
GNSS_LOC_SV_SYSTEM_SBAS = 3,
/**< SBAS satellite. */
GNSS_LOC_SV_SYSTEM_COMPASS = 4,
/**< COMPASS satellite. */
GNSS_LOC_SV_SYSTEM_GLONASS = 5,
/**< GLONASS satellite. */
GNSS_LOC_SV_SYSTEM_BDS = 6,
/**< BDS satellite. */
GNSS_LOC_SV_SYSTEM_QZSS = 7
/**< QZSS satellite. */
} Gnss_LocSvSystemEnumType;
typedef uint32_t GnssSystemTimeStructTypeFlags;
typedef enum {
GNSS_SYSTEM_TIME_WEEK_VALID = (1 << 0),
GNSS_SYSTEM_TIME_WEEK_MS_VALID = (1 << 1),
GNSS_SYSTEM_CLK_TIME_BIAS_VALID = (1 << 2),
GNSS_SYSTEM_CLK_TIME_BIAS_UNC_VALID = (1 << 3),
GNSS_SYSTEM_REF_FCOUNT_VALID = (1 << 4),
GNSS_SYSTEM_NUM_CLOCK_RESETS_VALID = (1 << 5)
} GnssSystemTimeTypeBits;
typedef uint32_t GnssGloTimeStructTypeFlags;
typedef enum {
GNSS_CLO_DAYS_VALID = (1 << 0),
GNSS_GLOS_MSEC_VALID = (1 << 1),
GNSS_GLO_CLK_TIME_BIAS_VALID = (1 << 2),
GNSS_GLO_CLK_TIME_BIAS_UNC_VALID = (1 << 3),
GNSS_GLO_REF_FCOUNT_VALID = (1 << 4),
GNSS_GLO_NUM_CLOCK_RESETS_VALID = (1 << 5),
GNSS_GLO_FOUR_YEAR_VALID = (1 << 6)
} GnssGloTimeTypeBits;
typedef struct {
GnssAidingDataSvMask svMask; // bitwise OR of GnssAidingDataSvBits
GnssAidingDataSvTypeMask svTypeMask; // bitwise OR of GnssAidingDataSvTypeBits
@ -499,6 +579,114 @@ typedef struct {
LocationTechnologyType techType; // GNSS
} GeofenceStatusNotification;
typedef struct {
uint64_t gpsSvUsedIdsMask;
uint64_t gloSvUsedIdsMask;
uint64_t galSvUsedIdsMask;
uint64_t bdsSvUsedIdsMask;
uint64_t qzssSvUsedIdsMask;
} GnssLocationSvUsedInPosition;
/** @struct
Body Frame parameters
*/
typedef struct {
GnssLocationPosDataMask bodyFrameDataMask; // Contains Body frame LocPosDataMask bits
float longAccel; // Forward Acceleration in body frame (m/s2)
float latAccel; // Sideward Acceleration in body frame (m/s2)
float vertAccel; // Vertical Acceleration in body frame (m/s2)
float yawRate; // Heading Rate (Radians/second)
float pitch; // Body pitch (Radians)
} GnssLocationPositionDynamics;
typedef struct {
/** Validity mask for below fields */
GnssSystemTimeStructTypeFlags validityMask;
/** Extended week number at reference tick.
Unit: Week.
Set to 65535 if week number is unknown.
For GPS:
Calculated from midnight, Jan. 6, 1980.
OTA decoded 10 bit GPS week is extended to map between:
[NV6264 to (NV6264 + 1023)].
NV6264: Minimum GPS week number configuration.
Default value of NV6264: 1738
For BDS:
Calculated from 00:00:00 on January 1, 2006 of Coordinated Universal Time (UTC).
For GAL:
Calculated from 00:00 UT on Sunday August 22, 1999 (midnight between August 21 and August 22).
*/
uint16_t systemWeek;
/** Time in to the current week at reference tick.
Unit: Millisecond. Range: 0 to 604799999.
Check for systemClkTimeUncMs before use */
uint32_t systemMsec;
/** System clock time bias (sub-millisecond)
Units: Millisecond
Note: System time (TOW Millisecond) = systemMsec - systemClkTimeBias.
Check for systemClkTimeUncMs before use. */
float systemClkTimeBias;
/** Single sided maximum time bias uncertainty
Units: Millisecond */
float systemClkTimeUncMs;
/** FCount (free running HW timer) value. Don't use for relative time purpose
due to possible discontinuities.
Unit: Millisecond */
uint32_t refFCount;
/** Number of clock resets/discontinuities detected, affecting the local hardware counter value. */
uint32_t numClockResets;
} GnssSystemTimeStructType;
typedef struct {
/** GLONASS day number in four years. Refer to GLONASS ICD.
Applicable only for GLONASS and shall be ignored for other constellations.
If unknown shall be set to 65535 */
uint16_t gloDays;
/** Validity mask for below fields */
GnssGloTimeStructTypeFlags validityMask;
/** GLONASS time of day in Millisecond. Refer to GLONASS ICD.
Units: Millisecond
Check for gloClkTimeUncMs before use */
uint32_t gloMsec;
/** GLONASS clock time bias (sub-millisecond)
Units: Millisecond
Note: GLO time (TOD Millisecond) = gloMsec - gloClkTimeBias.
Check for gloClkTimeUncMs before use. */
float gloClkTimeBias;
/** Single sided maximum time bias uncertainty
Units: Millisecond */
float gloClkTimeUncMs;
/** FCount (free running HW timer) value. Don't use for relative time purpose
due to possible discontinuities.
Unit: Millisecond */
uint32_t refFCount;
/** Number of clock resets/discontinuities detected, affecting the local hardware counter value. */
uint32_t numClockResets;
/** GLONASS four year number from 1996. Refer to GLONASS ICD.
Applicable only for GLONASS and shall be ignored for other constellations.
If unknown shall be set to 255 */
uint8_t gloFourYear;
} GnssGloTimeStructType;
typedef union {
GnssSystemTimeStructType gpsSystemTime;
GnssSystemTimeStructType galSystemTime;
GnssSystemTimeStructType bdsSystemTime;
GnssSystemTimeStructType qzssSystemTime;
GnssGloTimeStructType gloSytemTime;
} SystemTimeStructUnion;
/** Time applicability of PVT report */
typedef struct {
/** Specifies GNSS system time reported. Mandatory field */
Gnss_LocSvSystemEnumType gnssSystemTimeSrc;
/** Reporting of GPS system time is recommended.
If GPS time is unknown & other satellite system time is known,
it should be reported.
Mandatory field
*/
SystemTimeStructUnion u;
} GnssSystemTime;
typedef struct {
size_t size; // set to sizeof(GnssLocationInfo)
GnssLocationInfoFlagMask flags; // bitwise OR of GnssLocationInfoBits for param validity
@ -506,12 +694,27 @@ typedef struct {
float pdop; // position dilusion of precision
float hdop; // horizontal dilusion of precision
float vdop; // vertical dilusion of precision
float gdop; // geometric dilution of precision
float tdop; // time dilution of precision
float magneticDeviation; // magnetic deviation
LocationReliability horReliability; // horizontal reliability
LocationReliability verReliability; // vertical reliability
float horUncEllipseSemiMajor; // horizontal elliptical accuracy semi-major axis
float horUncEllipseSemiMinor; // horizontal elliptical accuracy semi-minor axis
float horUncEllipseOrientAzimuth; // horizontal elliptical accuracy azimuth
float northVelocity; // North Velocity.Unit: Meters/sec
float eastVelocity; // East Velocity
float upVelocity;
float northVelocityStdDeviation;
float eastVelocityStdDeviation;
float upVelocityStdDeviation;
GnssLocationSvUsedInPosition svUsedInPosition;// Gnss sv used in position data
GnssLocationNavSolutionMask navSolutionMask; // Nav solution mask to indicate sbas corrections
GnssLocationPosTechMask posTechMask; // Position technology used in computing this fix
GnssLocationPositionDynamics bodyFrameData; // Body Frame Dynamics: 4wayAcceleration and
// pitch set with validity
GnssSystemTime gnssSystemTime; // GNSS System Time
Location location;
} GnssLocationInfoNotification;
typedef struct {

26
utils/gps_extended_c.h
View file

@ -127,13 +127,6 @@ typedef struct {
/* Provider indicator for HYBRID or GPS */
uint16_t position_source;
LocPosTechMask tech_mask;
/*allows HAL to pass additional information related to the location */
int rawDataSize; /* in # of bytes */
void * rawData;
bool is_indoor;
float floor_number;
char map_url[GPS_LOCATION_MAP_URL_SIZE];
unsigned char map_index[GPS_LOCATION_MAP_INDEX_SIZE];
} UlpLocation;
typedef struct {
@ -728,25 +721,6 @@ enum ulp_gnss_sv_poly_valid_flags{
#define ULP_GNSS_SV_POLY_BIT_VELO_COEFF (1<<ULP_GNSS_SV_POLY_VELO_COEFF)
#define ULP_GNSS_SV_POLY_BIT_ENHANCED_IOD (1<<ULP_GNSS_SV_POLY_ENHANCED_IOD)
typedef enum
{
GNSS_LOC_SV_SYSTEM_GPS = 1,
/**< GPS satellite. */
GNSS_LOC_SV_SYSTEM_GALILEO = 2,
/**< GALILEO satellite. */
GNSS_LOC_SV_SYSTEM_SBAS = 3,
/**< SBAS satellite. */
GNSS_LOC_SV_SYSTEM_COMPASS = 4,
/**< COMPASS satellite. */
GNSS_LOC_SV_SYSTEM_GLONASS = 5,
/**< GLONASS satellite. */
GNSS_LOC_SV_SYSTEM_BDS = 6,
/**< BDS satellite. */
GNSS_LOC_SV_SYSTEM_QZSS = 7
/**< QZSS satellite. */
} Gnss_LocSvSystemEnumType;
typedef enum
{
GNSS_LOC_FREQ_SOURCE_INVALID = 0,