Piteball/android_device_samsung_msm8226-common
1
0
Fork 0
mirror of https://github.com/S3NEO/android_device_samsung_msm8226-common.git synced 2024-11-06 21:55:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

Changes for External DR enablement feature.

Browse source 
Change Summary:
* Structure definitions for GNSS SV Measurement and GNSS SV
  Polynomial to report it to ULP and to external DR module;
* New function additions in LocApiBase, LocAdapterBase and
  LocEngAdapter to report SV Measurement and SV Polynomial;
* definition and changes to detect "auto" platform in loc_target;
* enable SV Measurement and SV Polynomial report for "auto"
  platform;

Change-Id: I0611023197ce58f5d083588809c2f18922738357
This commit is contained in:
Kevin Tang 2014-07-18 09:14:16 -07:00 committed by Rox-
parent 932151ebaa
commit e9478c11bb
12 changed files with 666 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
gps/core/LocAdapterBase.cpp
View file

@ -66,6 +66,13 @@ void LocAdapterBase::
void* svExt)
DEFAULT_IMPL()
void LocAdapterBase::
reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet)
DEFAULT_IMPL()
void LocAdapterBase::
reportSvPolynomial(GnssSvPolynomial &svPolynomial)
DEFAULT_IMPL()
void LocAdapterBase::
reportStatus(GpsStatusValue status)

2
gps/core/LocAdapterBase.h
View file

@ -82,6 +82,8 @@ public:
virtual void reportSv(GpsSvStatus &svStatus,
GpsLocationExtended &locationExtended,
void* svExt);
virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
virtual void reportStatus(GpsStatusValue status);
virtual void reportNmea(const char* nmea, int length);
virtual bool reportXtraServer(const char* url1, const char* url2,

16
gps/core/LocApiBase.cpp
View file

@ -244,6 +244,22 @@ void LocApiBase::reportSv(GpsSvStatus &svStatus,
);
}
void LocApiBase::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet)
{
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
mLocAdapters[i]->reportSvMeasurement(svMeasurementSet)
);
}
void LocApiBase::reportSvPolynomial(GnssSvPolynomial &svPolynomial)
{
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
mLocAdapters[i]->reportSvPolynomial(svPolynomial)
);
}
void LocApiBase::reportStatus(GpsStatusValue status)
{
// loop through adapters, and deliver to all adapters.

2
gps/core/LocApiBase.h
View file

@ -105,6 +105,8 @@ public:
void reportSv(GpsSvStatus &svStatus,
GpsLocationExtended &locationExtended,
void* svExt);
void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
void reportStatus(GpsStatusValue status);
void reportNmea(const char* nmea, int length);
void reportXtraServer(const char* url1, const char* url2,

8
gps/core/UlpProxyBase.h
View file

@ -62,6 +62,14 @@ public:
void* svExt) {
return false;
}
inline virtual bool reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) {
return false;
}
inline virtual bool reportSvPolynomial(GnssSvPolynomial &svPolynomial)
{
return false;
}
inline virtual bool reportStatus(GpsStatusValue status) {
return false;
}

591
gps/core/gps_extended_c.h
View file

@ -60,6 +60,8 @@ extern "C" {
#define ULP_LOCATION_IS_FROM_ZPP 0x0004
/** Position is from a Geofence Breach Event */
#define ULP_LOCATION_IS_FROM_GEOFENCE 0X0008
/** Position is from a Geofence Breach Event */
#define ULP_LOCATION_IS_FROM_EXT_DR 0X0010
#define ULP_MIN_INTERVAL_INVALID 0xffffffff
@ -313,6 +315,8 @@ enum loc_api_adapter_event_index {
LOC_API_ADAPTER_BATCH_FULL, // Batching on full
LOC_API_ADAPTER_BATCHED_POSITION_REPORT, // Batching on fix
LOC_API_ADAPTER_BATCHED_GENFENCE_BREACH_REPORT, //
LOC_API_ADAPTER_GNSS_MEASUREMENT_REPORT, //GNSS Measurement Report
LOC_API_ADAPTER_GNSS_SV_POLYNOMIAL_REPORT, //GNSS SV Polynomial Report
LOC_API_ADAPTER_EVENT_MAX
};
@ -339,13 +343,598 @@ enum loc_api_adapter_event_index {
#define LOC_API_ADAPTER_BIT_REQUEST_WIFI_AP_DATA (1<<LOC_API_ADAPTER_REQUEST_WIFI_AP_DATA)
#define LOC_API_ADAPTER_BIT_BATCH_FULL (1<<LOC_API_ADAPTER_BATCH_FULL)
#define LOC_API_ADAPTER_BIT_BATCHED_POSITION_REPORT (1<<LOC_API_ADAPTER_BATCHED_POSITION_REPORT)
#define LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT (1<<LOC_API_ADAPTER_GNSS_MEASUREMENT_REPORT)
#define LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT (1<<LOC_API_ADAPTER_GNSS_SV_POLYNOMIAL_REPORT)
typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
/*++ ***********************************************
** Satellite Measurement and Satellite Polynomial
** Structure definitions
** ***********************************************
--*/
#define GNSS_SV_POLY_VELOCITY_COEF_MAX_SIZE 12
#define GNSS_SV_POLY_XYZ_0_TH_ORDER_COEFF_MAX_SIZE 3
#define GNSS_SV_POLY_XYZ_N_TH_ORDER_COEFF_MAX_SIZE 9
#define GNSS_SV_POLY_SV_CLKBIAS_COEFF_MAX_SIZE 4
#define GNSS_LOC_SV_MEAS_LIST_MAX_SIZE 16
enum ulp_gnss_sv_measurement_valid_flags{
ULP_GNSS_SV_MEAS_GPS_TIME = 0,
ULP_GNSS_SV_MEAS_PSUEDO_RANGE,
ULP_GNSS_SV_MEAS_MS_IN_WEEK,
ULP_GNSS_SV_MEAS_SUB_MSEC,
ULP_GNSS_SV_MEAS_CARRIER_PHASE,
ULP_GNSS_SV_MEAS_DOPPLER_SHIFT,
ULP_GNSS_SV_MEAS_CNO,
ULP_GNSS_SV_MEAS_LOSS_OF_LOCK,
ULP_GNSS_SV_MEAS_MAX_VALID_FLAGS
};
#define ULP_GNSS_SV_MEAS_BIT_GPS_TIME (1<<ULP_GNSS_SV_MEAS_GPS_TIME)
#define ULP_GNSS_SV_MEAS_BIT_PSUEDO_RANGE (1<<ULP_GNSS_SV_MEAS_PSUEDO_RANGE)
#define ULP_GNSS_SV_MEAS_BIT_MS_IN_WEEK (1<<ULP_GNSS_SV_MEAS_MS_IN_WEEK)
#define ULP_GNSS_SV_MEAS_BIT_SUB_MSEC (1<<ULP_GNSS_SV_MEAS_SUB_MSEC)
#define ULP_GNSS_SV_MEAS_BIT_CARRIER_PHASE (1<<ULP_GNSS_SV_MEAS_CARRIER_PHASE)
#define ULP_GNSS_SV_MEAS_BIT_DOPPLER_SHIFT (1<<ULP_GNSS_SV_MEAS_DOPPLER_SHIFT)
#define ULP_GNSS_SV_MEAS_BIT_CNO (1<<ULP_GNSS_SV_MEAS_CNO)
#define ULP_GNSS_SV_MEAS_BIT_LOSS_OF_LOCK (1<<ULP_GNSS_SV_MEAS_LOSS_OF_LOCK)
enum ulp_gnss_sv_poly_valid_flags{
ULP_GNSS_SV_POLY_GLO_FREQ = 0,
ULP_GNSS_SV_POLY_T0,
ULP_GNSS_SV_POLY_IODE,
ULP_GNSS_SV_POLY_FLAG,
ULP_GNSS_SV_POLY_POLYCOEFF_XYZ0,
ULP_GNSS_SV_POLY_POLYCOEFF_XYZN,
ULP_GNSS_SV_POLY_POLYCOEFF_OTHER,
ULP_GNSS_SV_POLY_SV_POSUNC,
ULP_GNSS_SV_POLY_IONODELAY,
ULP_GNSS_SV_POLY_IONODOT,
ULP_GNSS_SV_POLY_SBAS_IONODELAY,
ULP_GNSS_SV_POLY_SBAS_IONODOT,
ULP_GNSS_SV_POLY_TROPODELAY,
ULP_GNSS_SV_POLY_ELEVATION,
ULP_GNSS_SV_POLY_ELEVATIONDOT,
ULP_GNSS_SV_POLY_ELEVATIONUNC,
ULP_GNSS_SV_POLY_VELO_COEFF,
ULP_GNSS_SV_POLY_VALID_FLAGS
};
#define ULP_GNSS_SV_POLY_BIT_GLO_FREQ (1<<ULP_GNSS_SV_POLY_GLO_FREQ)
#define ULP_GNSS_SV_POLY_BIT_T0 (1<<ULP_GNSS_SV_POLY_T0)
#define ULP_GNSS_SV_POLY_BIT_IODE (1<<ULP_GNSS_SV_POLY_IODE)
#define ULP_GNSS_SV_POLY_BIT_FLAG (1<<ULP_GNSS_SV_POLY_FLAG)
#define ULP_GNSS_SV_POLY_BIT_POLYCOEFF_XYZ0 (1<<ULP_GNSS_SV_POLY_POLYCOEFF_XYZ0)
#define ULP_GNSS_SV_POLY_BIT_POLYCOEFF_XYZN (1<<ULP_GNSS_SV_POLY_POLYCOEFF_XYZN)
#define ULP_GNSS_SV_POLY_BIT_POLYCOEFF_OTHER (1<<ULP_GNSS_SV_POLY_POLYCOEFF_OTHER)
#define ULP_GNSS_SV_POLY_BIT_SV_POSUNC (1<<ULP_GNSS_SV_POLY_SV_POSUNC)
#define ULP_GNSS_SV_POLY_BIT_IONODELAY (1<<ULP_GNSS_SV_POLY_IONODELAY)
#define ULP_GNSS_SV_POLY_BIT_IONODOT (1<<ULP_GNSS_SV_POLY_IONODOT)
#define ULP_GNSS_SV_POLY_BIT_SBAS_IONODELAY (1<<ULP_GNSS_SV_POLY_SBAS_IONODELAY)
#define ULP_GNSS_SV_POLY_BIT_SBAS_IONODOT (1<<ULP_GNSS_SV_POLY_SBAS_IONODOT)
#define ULP_GNSS_SV_POLY_BIT_TROPODELAY (1<<ULP_GNSS_SV_POLY_TROPODELAY)
#define ULP_GNSS_SV_POLY_BIT_ELEVATION (1<<ULP_GNSS_SV_POLY_ELEVATION)
#define ULP_GNSS_SV_POLY_BIT_ELEVATIONDOT (1<<ULP_GNSS_SV_POLY_ELEVATIONDOT)
#define ULP_GNSS_SV_POLY_BIT_ELEVATIONUNC (1<<ULP_GNSS_SV_POLY_ELEVATIONUNC)
#define ULP_GNSS_SV_POLY_BIT_VELO_COEFF (1<<ULP_GNSS_SV_POLY_VELO_COEFF)
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_LocSvSystemEnumType;
typedef enum
{
GNSS_LOC_FREQ_SOURCE_INVALID = 0,
/**< Source of the frequency is invalid */
GNSS_LOC_FREQ_SOURCE_EXTERNAL = 1,
/**< Source of the frequency is from external injection */
GNSS_LOC_FREQ_SOURCE_PE_CLK_REPORT = 2,
/**< Source of the frequency is from Navigation engine */
GNSS_LOC_FREQ_SOURCE_UNKNOWN = 3
/**< Source of the frequency is unknown */
} Gnss_LocSourceofFreqEnumType;
typedef struct
{
size_t size;
float clockDrift;
/**< Receiver clock Drift \n
- Units: meter per sec \n
*/
float clockDriftUnc;
/**< Receiver clock Drift uncertainty \n
- Units: meter per sec \n
*/
Gnss_LocSourceofFreqEnumType sourceOfFreq;
}Gnss_LocRcvrClockFrequencyInfoStructType;
typedef struct
{
size_t size;
uint8_t leapSec;
/**< GPS time leap second delta to UTC time \n
- Units: sec \n
*/
uint8_t leapSecUnc;
/**< Uncertainty for GPS leap second \n
- Units: sec \n
*/
}Gnss_LeapSecondInfoStructType;
typedef enum
{
GNSS_LOC_SYS_TIME_BIAS_VALID = 0x01,
/**< System time bias valid */
GNSS_LOC_SYS_TIME_BIAS_UNC_VALID = 0x02,
/**< System time bias uncertainty valid */
}Gnss_LocInterSystemBiasValidMaskType;
typedef struct
{
size_t size;
uint32_t validMask;
/* Validity mask as per Gnss_LocInterSystemBiasValidMaskType */
float timeBias;
/**< System-1 to System-2 Time Bias \n
- Units: msec \n
*/
float timeBiasUnc;
/**< System-1 to System-2 Time Bias uncertainty \n
- Units: msec \n
*/
}Gnss_InterSystemBiasStructType;
typedef struct
{
size_t size;
uint16_t systemWeek;
/**< System week number for GPS, BDS and GAL satellite systems. \n
Set to 65535 when invalid or not available. \n
Not valid for GLONASS system. \n
*/
uint32_t systemMsec;
/**< System time msec. Time of Week for GPS, BDS, GAL and
Time of Day for GLONASS.
- Units: msec \n
*/
float systemClkTimeBias;
/**< System clock time bias \n
- Units: msec \n
System time = systemMsec - systemClkTimeBias \n
*/
float systemClkTimeUncMs;
/**< Single sided maximum time bias uncertainty \n
- Units: msec \n
*/
}Gnss_LocSystemTimeStructType;
typedef struct {
size_t size;
uint8_t gloFourYear;
/**< GLONASS four year number from 1996. Refer to GLONASS ICD.\n
Applicable only for GLONASS and shall be ignored for other constellations. \n
If unknown shall be set to 255
*/
uint16_t gloDays;
/**< GLONASS day number in four years. Refer to GLONASS ICD.
Applicable only for GLONASS and shall be ignored for other constellations. \n
If unknown shall be set to 65535
*/
uint32_t gloMsec;
/**< GLONASS time of day in msec. Refer to GLONASS ICD.
- Units: msec \n
*/
float gloClkTimeBias;
/**< System clock time bias (sub-millisecond) \n
- Units: msec \n
System time = systemMsec - systemClkTimeBias \n
*/
float gloClkTimeUncMs;
/**< Single sided maximum time bias uncertainty \n
- Units: msec \n
*/
}Gnss_LocGloTimeStructType; /* Type */
typedef struct {
size_t size;
uint32_t refFCount;
/**< Receiver frame counter value at reference tick */
uint8_t systemRtc_valid;
/**< Validity indicator for System RTC */
uint64_t systemRtcMs;
/**< Platform system RTC value \n
- Units: msec \n
*/
uint32_t sourceOfTime;
/**< Source of time information */
}Gnss_LocGnssTimeExtStructType;
typedef enum
{
GNSS_LOC_MEAS_STATUS_NULL = 0x00000000,
/**< No information state */
GNSS_LOC_MEAS_STATUS_SM_VALID = 0x00000001,
/**< Code phase is known */
GNSS_LOC_MEAS_STATUS_SB_VALID = 0x00000002,
/**< Sub-bit time is known */
GNSS_LOC_MEAS_STATUS_MS_VALID = 0x00000004,
/**< Satellite time is known */
GNSS_LOC_MEAS_STATUS_BE_CONFIRM = 0x00000008,
/**< Bit edge is confirmed from signal */
GNSS_LOC_MEAS_STATUS_VELOCITY_VALID = 0x00000010,
/**< Satellite Doppler measured */
GNSS_LOC_MEAS_STATUS_VELOCITY_FINE = 0x00000020,
/**< TRUE: Fine Doppler measured, FALSE: Coarse Doppler measured */
GNSS_LOC_MEAS_STATUS_FROM_RNG_DIFF = 0x00000200,
/**< Range update from Satellite differences */
GNSS_LOC_MEAS_STATUS_FROM_VE_DIFF = 0x00000400,
/**< Doppler update from Satellite differences */
GNSS_LOC_MEAS_STATUS_DONT_USE_X = 0x00000800,
/**< Don't use measurement if bit is set */
GNSS_LOC_MEAS_STATUS_DONT_USE_M = 0x000001000,
/**< Don't use measurement if bit is set */
GNSS_LOC_MEAS_STATUS_DONT_USE_D = 0x000002000,
/**< Don't use measurement if bit is set */
GNSS_LOC_MEAS_STATUS_DONT_USE_S = 0x000004000,
/**< Don't use measurement if bit is set */
GNSS_LOC_MEAS_STATUS_DONT_USE_P = 0x000008000
/**< Don't use measurement if bit is set */
}Gnss_LocSvMeasStatusMaskType;
typedef struct
{
size_t size;
uint32_t svMs;
/**< Satellite time milisecond.\n
For GPS, BDS, GAL range of 0 thru (604800000-1) \n
For GLONASS range of 0 thru (86400000-1) \n
Valid when PD_LOC_MEAS_STATUS_MS_VALID bit is set in measurement status \n
Note: All SV times in the current measurement block are alredy propagated to common reference time epoch. \n
- Units: msec \n
*/
float svSubMs;
/**<Satellite time sub-millisecond. \n
Total SV Time = svMs + svSubMs \n
- Units: msec \n
*/
float svTimeUncMs;
/**< Satellite Time uncertainty \n
- Units: msec \n
*/
float dopplerShift;
/**< Satellite Doppler \n
- Units: meter per sec \n
*/
float dopplerShiftUnc;
/**< Satellite Doppler uncertainty\n
- Units: meter per sec \n
*/
}Gnss_LocSVTimeSpeedStructType;
typedef enum
{
GNSS_SV_STATE_IDLE = 0,
GNSS_SV_STATE_SEARCH = 1,
GNSS_SV_STATE_SEARCH_VERIFY = 2,
GNSS_SV_STATE_BIT_EDGE = 3,
GNSS_SV_STATE_VERIFY_TRACK = 4,
GNSS_SV_STATE_TRACK = 5,
GNSS_SV_STATE_RESTART = 6,
GNSS_SV_STATE_DPO_TRACK = 7
} Gnss_LocSVStateEnumType;
typedef enum
{
GNSS_LOC_SVINFO_MASK_HAS_EPHEMERIS = 0x01,
/**< Ephemeris is available for this SV */
GNSS_LOC_SVINFO_MASK_HAS_ALMANAC = 0x02
/**< Almanac is available for this SV */
}Gnss_LocSvInfoMaskT;
typedef enum
{
GNSS_LOC_SV_SRCH_STATUS_IDLE = 1,
/**< SV is not being actively processed */
GNSS_LOC_SV_SRCH_STATUS_SEARCH = 2,
/**< The system is searching for this SV */
GNSS_LOC_SV_SRCH_STATUS_TRACK = 3
/**< SV is being tracked */
}Gnss_LocSvSearchStatusEnumT;
typedef struct
{
size_t size;
uint16_t gnssSvId;
/**< GNSS SV ID.
\begin{itemize1}
\item Range: \begin{itemize1}
\item For GPS: 1 to 32
\item For GLONASS: 1 to 32
\item For SBAS: 120 to 151
\item For BDS: 201 to 237
\end{itemize1} \end{itemize1}
The GPS and GLONASS SVs can be disambiguated using the system field.
*/
uint8_t gloFrequency;
/**< GLONASS frequency number + 7 \n
Valid only for GLONASS System \n
Shall be ignored for all other systems \n
- Range: 1 to 14 \n
*/
Gnss_LocSvSearchStatusEnumT svStatus;
/**< Satellite search state \n
@ENUM()
*/
bool healthStatus_valid;
/**< SV Health Status validity flag\n
- 0: Not valid \n
- 1: Valid \n
*/
uint8_t healthStatus;
/**< Health status.
\begin{itemize1}
\item Range: 0 to 1; 0 = unhealthy, \n 1 = healthy, 2 = unknown
\vspace{-0.18in} \end{itemize1}
*/
Gnss_LocSvInfoMaskT svInfoMask;
/**< Indicates whether almanac and ephemeris information is available. \n
@MASK()
*/
uint64_t measurementStatus;
/**< Bitmask indicating SV measurement status.
Valid bitmasks: \n
@MASK()
*/
uint16_t CNo;
/**< Carrier to Noise ratio \n
- Units: 0.1 dBHz \n
*/
uint16_t gloRfLoss;
/**< GLONASS Rf loss reference to Antenna. \n
- Units: dB, Scale: 0.1 \n
*/
bool lossOfLock;
/**< Loss of signal lock indicator \n
- 0: Signal in continuous track \n
- 1: Signal not in track \n
*/
int16_t measLatency;
/**< Age of the measurement. Positive value means measurement precedes ref time. \n
- Units: msec \n
*/
Gnss_LocSVTimeSpeedStructType svTimeSpeed;
/**< Unfiltered SV Time and Speed information
*/
float dopplerAccel;
/**< Satellite Doppler Accelertion\n
- Units: Hz/s \n
*/
bool multipathEstValid;
/**< Multipath estimate validity flag\n
- 0: Multipath estimate not valid \n
- 1: Multipath estimate valid \n
*/
float multipathEstimate;
/**< Estimate of multipath in measurement\n
- Units: Meters \n
*/
bool fineSpeedValid;
/**< Fine speed validity flag\n
- 0: Fine speed not valid \n
- 1: Fine speed valid \n
*/
float fineSpeed;
/**< Carrier phase derived speed \n
- Units: m/s \n
*/
bool fineSpeedUncValid;
/**< Fine speed uncertainty validity flag\n
- 0: Fine speed uncertainty not valid \n
- 1: Fine speed uncertainty valid \n
*/
float fineSpeedUnc;
/**< Carrier phase derived speed \n
- Units: m/s \n
*/
bool carrierPhaseValid;
/**< Carrier Phase measurement validity flag\n
- 0: Carrier Phase not valid \n
- 1: Carrier Phase valid \n
*/
double carrierPhase;
/**< Carrier phase measurement [L1 cycles] \n
*/
bool cycleSlipCountValid;
/**< Cycle slup count validity flag\n
- 0: Not valid \n
- 1: Valid \n
*/
uint8_t cycleSlipCount;
/**< Increments when a CSlip is detected */
bool svDirectionValid;
/**< Validity flag for SV direction */
float svAzimuth;
/**< Satellite Azimuth
- Units: radians \n
*/
float svElevation;
/**< Satellite Elevation
- Units: radians \n
*/
} Gnss_SVMeasurementStructType;
/**< Maximum number of satellites in measurement block for given system. */
typedef struct
{
size_t size;
Gnss_LocSvSystemEnumType system;
/**< Specifies the Satellite System Type
*/
bool isSystemTimeValid;
/**< Indicates whether System Time is Valid:\n
- 0x01 (TRUE) -- System Time is valid \n
- 0x00 (FALSE) -- System Time is not valid
*/
Gnss_LocSystemTimeStructType systemTime;
/**< System Time Information \n
*/
bool isGloTime_valid;
Gnss_LocGloTimeStructType gloTime;
bool isSystemTimeExt_valid;
Gnss_LocGnssTimeExtStructType systemTimeExt;
uint8_t numSvs;
/* Number of SVs in this report block */
Gnss_SVMeasurementStructType svMeasurement[GNSS_LOC_SV_MEAS_LIST_MAX_SIZE];
/**< Satellite measurement Information \n
*/
} Gnss_ClockMeasurementStructType;
typedef struct
{
size_t size;
uint8_t seqNum;
/**< Current message Number */
uint8_t maxMessageNum;
/**< Maximum number of message that will be sent for present time epoch. */
bool leapSecValid;
Gnss_LeapSecondInfoStructType leapSec;
Gnss_InterSystemBiasStructType gpsGloInterSystemBias;
Gnss_InterSystemBiasStructType gpsBdsInterSystemBias;
Gnss_InterSystemBiasStructType gpsGalInterSystemBias;
Gnss_InterSystemBiasStructType bdsGloInterSystemBias;
Gnss_InterSystemBiasStructType galGloInterSystemBias;
Gnss_InterSystemBiasStructType galBdsInterSystemBias;
bool clockFreqValid;
Gnss_LocRcvrClockFrequencyInfoStructType clockFreq; /* Freq */
bool gnssMeasValid;
Gnss_ClockMeasurementStructType gnssMeas;
} GnssSvMeasurementSet;
typedef enum
{
GNSS_SV_POLY_COEFF_VALID = 0x01,
/**< SV position in orbit coefficients are valid */
GNSS_SV_POLY_IONO_VALID = 0x02,
/**< Iono estimates are valid */
GNSS_SV_POLY_TROPO_VALID = 0x04,
/**< Tropo estimates are valid */
GNSS_SV_POLY_ELEV_VALID = 0x08,
/**< Elevation, rate, uncertainty are valid */
GNSS_SV_POLY_SRC_ALM_CORR = 0x10,
/**< Polynomials based on XTRA */
GNSS_SV_POLY_SBAS_IONO_VALID = 0x20,
/**< SBAS IONO and rate are valid */
GNSS_SV_POLY_GLO_STR4 = 0x40
/**< GLONASS String 4 has been received */
}Gnss_SvPolyStatusMaskType;
typedef struct
{
size_t size;
uint8_t gnssSvId;
/* GPS: 1-32, GLO: 65-96, 0: Invalid
All others are reserved
*/
int8_t freqNum;
/* Freq index, only valid if u_SysInd is GLO */
uint8_t svPolyFlags;
/* Indicate the validity of the elements
as per Gnss_SvPolyStatusMaskType
*/
uint16_t is_valid;
uint8_t iode;
/* Ephemeris reference time
GPS:Issue of Data Ephemeris used [unitless].
GLO: Tb 7-bit, refer to ICD02
*/
double T0;
/* Reference time for polynominal calculations
GPS: Secs in week.
GLO: Full secs since Jan/01/96
*/
double polyCoeffXYZ0[GNSS_SV_POLY_XYZ_0_TH_ORDER_COEFF_MAX_SIZE];
/* C0X, C0Y, C0Z */
double polyCoefXYZN[GNSS_SV_POLY_XYZ_N_TH_ORDER_COEFF_MAX_SIZE];
/* C1X, C2X ... C2Z, C3Z */
float polyCoefOther[GNSS_SV_POLY_SV_CLKBIAS_COEFF_MAX_SIZE];
/* C0T, C1T, C2T, C3T */
float svPosUnc; /* SV position uncertainty [m]. */
float ionoDelay; /* Ionospheric delay at d_T0 [m]. */
float ionoDot; /* Iono delay rate [m/s]. */
float sbasIonoDelay;/* SBAS Ionospheric delay at d_T0 [m]. */
float sbasIonoDot; /* SBAS Iono delay rate [m/s]. */
float tropoDelay; /* Tropospheric delay [m]. */
float elevation; /* Elevation [rad] at d_T0 */
float elevationDot; /* Elevation rate [rad/s] */
float elevationUnc; /* SV elevation [rad] uncertainty */
double velCoef[GNSS_SV_POLY_VELOCITY_COEF_MAX_SIZE];
/* Coefficients of velocity poly */
} GnssSvPolynomial;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* GPS_EXTENDED_C_H */

17
gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
View file

@ -178,6 +178,23 @@ void LocEngAdapter::reportSv(GpsSvStatus &svStatus,
}
}
void LocEngAdapter::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet)
{
// We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
if (! mUlp->reportSvMeasurement(svMeasurementSet)) {
//Send to Internal Adapter later if needed by LA
}
}
void LocEngAdapter::reportSvPolynomial(GnssSvPolynomial &svPolynomial)
{
// We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
if (! mUlp->reportSvPolynomial(svPolynomial)) {
//Send to Internal Adapter later if needed by LA
}
}
void LocEngAdapter::setInSession(bool inSession)
{
mNavigating = inSession;

2
gps/loc_api/libloc_api_50001/LocEngAdapter.h
View file

@ -260,6 +260,8 @@ public:
virtual void reportSv(GpsSvStatus &svStatus,
GpsLocationExtended &locationExtended,
void* svExt);
virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
virtual void reportStatus(GpsStatusValue status);
virtual void reportNmea(const char* nmea, int length);
virtual bool reportXtraServer(const char* url1, const char* url2,

13
gps/loc_api/libloc_api_50001/loc.cpp
View file

@ -197,6 +197,7 @@ extern "C" const GpsInterface* get_gps_interface()
switch (gnssType)
{
case GNSS_GSS:
case GNSS_AUTO:
//APQ8064
gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
gss_fd = open("/dev/gss", O_RDONLY);
@ -241,8 +242,9 @@ SIDE EFFECTS
static int loc_init(GpsCallbacks* callbacks)
{
int retVal = -1;
ENTRY_LOG();
unsigned int target = (unsigned int) -1;
LOC_API_ADAPTER_EVENT_MASK_T event;
ENTRY_LOG();
if (NULL == callbacks) {
LOC_LOGE("loc_init failed. cb = NULL\n");
@ -259,6 +261,15 @@ static int loc_init(GpsCallbacks* callbacks)
LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
target = loc_get_target();
/*For "auto" platform enable Measurement report and SV Polynomial report*/
if(GNSS_AUTO == getTargetGnssType(target))
{
event |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT |
LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT;
}
LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */
callbacks->status_cb, /* status_cb */
local_sv_cb, /* sv_status_cb */

1
gps/utils/loc_log.cpp
View file

@ -113,6 +113,7 @@ loc_name_val_s_type target_name[] =
NAME_VAL(GNSS_GSS),
NAME_VAL(GNSS_MDM),
NAME_VAL(GNSS_QCA1530),
NAME_VAL(GNSS_AUTO),
NAME_VAL(GNSS_UNKNOWN)
};

9
gps/utils/loc_target.cpp
View file

@ -205,8 +205,13 @@ unsigned int loc_get_target(void)
read_a_line(id_dep, rd_id, LINE_LEN);
}
if(( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ) ||
(!memcmp(baseband, STR_AUTO, LENGTH(STR_AUTO))) ) {
if( !memcmp(baseband, STR_AUTO, LENGTH(STR_AUTO)) )
{
gTarget = TARGET_AUTO;
goto detected;
}
if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ){
if( !memcmp(rd_id, MPQ8064_ID_1, LENGTH(MPQ8064_ID_1))
&& IS_STR_END(rd_id[LENGTH(MPQ8064_ID_1)]) )
gTarget = TARGET_MPQ;

2
gps/utils/loc_target.h
View file

@ -35,6 +35,7 @@
#define TARGET_MPQ TARGET_SET(GNSS_NONE,NO_SSC)
#define TARGET_MSM_NO_SSC TARGET_SET(GNSS_MSM, NO_SSC)
#define TARGET_QCA1530 TARGET_SET(GNSS_QCA1530, NO_SSC)
#define TARGET_AUTO TARGET_SET(GNSS_AUTO, NO_SSC)
#define TARGET_UNKNOWN TARGET_SET(GNSS_UNKNOWN, NO_SSC)
#define getTargetGnssType(target) (target>>1)
@ -60,6 +61,7 @@ typedef enum {
GNSS_GSS,
GNSS_MDM,
GNSS_QCA1530,
GNSS_AUTO,
GNSS_UNKNOWN
}GNSS_TARGET;