From 75cfd43bfdab4fb478e1504808a418320f5dcd95 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Thu, 7 Jun 2018 16:54:35 -0700 Subject: [PATCH] Add jammer indication Add AGC and jammer indication Change-Id: I93641864338beec368e7a56b3a20b158ea892202 CRs-fixed: 2239155 --- core/LocAdapterBase.cpp | 10 +- core/LocAdapterBase.h | 10 +- core/LocAdapterProxyBase.h | 1 - core/LocApiBase.cpp | 38 ++++++- core/LocApiBase.h | 7 +- gnss/GnssAdapter.cpp | 173 ++++++++++++++++++++++++++++++- gnss/GnssAdapter.h | 8 +- location/LocationAPI.cpp | 1 + location/LocationAPIClientBase.h | 1 + location/LocationDataTypes.h | 45 ++++++++ 10 files changed, 283 insertions(+), 11 deletions(-) diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp index 8301ee86..8197f4df 100644 --- a/core/LocAdapterBase.cpp +++ b/core/LocAdapterBase.cpp @@ -80,7 +80,10 @@ void LocAdapterBase:: const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask, - bool /*fromEngineHub*/) { + bool /*fromEngineHub*/, + GnssDataNotification* pDataNotify, + int msInWeek) +{ if (mLocAdapterProxyBase != NULL) { mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location, (GpsLocationExtended&)locationExtended, @@ -113,6 +116,11 @@ void LocAdapterBase:: reportNmeaEvent(const char* /*nmea*/, size_t /*length*/) DEFAULT_IMPL() +void LocAdapterBase:: + reportDataEvent(const GnssDataNotification& /*dataNotify*/, + int /*msInWeek*/) +DEFAULT_IMPL() + bool LocAdapterBase:: reportXtraServer(const char* /*url1*/, const char* /*url2*/, const char* /*url3*/, const int /*maxlength*/) diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h index e3502b21..6b3e02ff 100644 --- a/core/LocAdapterBase.h +++ b/core/LocAdapterBase.h @@ -113,6 +113,11 @@ public: mLocApi->updateEvtMask(); } + inline void updateNmeaMask(uint32_t mask) + { + mLocApi->updateNmeaMask(mask); + } + inline bool isFeatureSupported(uint8_t featureVal) { return ContextBase::isFeatureSupported(featureVal); } @@ -133,9 +138,12 @@ public: const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask, - bool fromEngineHub=false); + bool fromEngineHub = false, + GnssDataNotification* pDataNotify = nullptr, + int msInWeek = -1); virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromEngineHub=false); + virtual void reportDataEvent(const GnssDataNotification& dataNotify, int msInWeek); virtual void reportNmeaEvent(const char* nmea, size_t length); virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet); virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial); diff --git a/core/LocAdapterProxyBase.h b/core/LocAdapterProxyBase.h index 044f59bd..b33d7b0e 100644 --- a/core/LocAdapterProxyBase.h +++ b/core/LocAdapterProxyBase.h @@ -65,7 +65,6 @@ public: GpsLocationExtended &locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { - (void)location; (void)locationExtended; (void)status; diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index a82e30b2..7a0900b0 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -240,6 +240,30 @@ void LocApiBase::updateEvtMask() mMsgTask->sendMsg(new LocOpenMsg(this)); } +void LocApiBase::updateNmeaMask(uint32_t mask) +{ + struct LocSetNmeaMsg : public LocMsg { + LocApiBase* mLocApi; + uint32_t mMask; + inline LocSetNmeaMsg(LocApiBase* locApi, uint32_t mask) : + LocMsg(), mLocApi(locApi), mMask(mask) + { + locallog(); + } + inline virtual void proc() const { + mLocApi->setNMEATypesSync(mMask); + } + inline void locallog() const { + LOC_LOGv("LocSyncNmea NmeaMask: %" PRIx32 "\n", mMask); + } + inline virtual void log() const { + locallog(); + } + }; + + mMsgTask->sendMsg(new LocSetNmeaMsg(this, mask)); +} + void LocApiBase::handleEngineUpEvent() { LocDualContext::injectFeatureConfig(mContext); @@ -259,7 +283,9 @@ void LocApiBase::handleEngineDownEvent() void LocApiBase::reportPosition(UlpLocation& location, GpsLocationExtended& locationExtended, enum loc_sess_status status, - LocPosTechMask loc_technology_mask) + LocPosTechMask loc_technology_mask, + GnssDataNotification* pDataNotify, + int msInWeek) { // print the location info before delivering LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " @@ -281,7 +307,9 @@ void LocApiBase::reportPosition(UlpLocation& location, // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( mLocAdapters[i]->reportPositionEvent(location, locationExtended, - status, loc_technology_mask) + status, loc_technology_mask, + false, + pDataNotify, msInWeek) ); } @@ -363,6 +391,12 @@ void LocApiBase::reportStatus(LocGpsStatusValue status) TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status)); } +void LocApiBase::reportData(GnssDataNotification& dataNotify, int msInWeek) +{ + // loop through adapters, and deliver to all adapters. + TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportDataEvent(dataNotify, msInWeek)); +} + void LocApiBase::reportNmea(const char* nmea, int length) { // loop through adapters, and deliver to all adapters. diff --git a/core/LocApiBase.h b/core/LocApiBase.h index b50a973c..538db303 100644 --- a/core/LocApiBase.h +++ b/core/LocApiBase.h @@ -116,6 +116,7 @@ protected: close(); LOC_API_ADAPTER_EVENT_MASK_T getEvtMask(); LOC_API_ADAPTER_EVENT_MASK_T mMask; + uint32_t mNmeaMask; LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask, ContextBase* context = NULL); inline virtual ~LocApiBase() { @@ -154,12 +155,15 @@ public: GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask = - LOC_POS_TECH_MASK_DEFAULT); + LOC_POS_TECH_MASK_DEFAULT, + GnssDataNotification* pDataNotify = nullptr, + int msInWeek = -1); void reportSv(GnssSvNotification& svNotify); void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); void reportSvPolynomial(GnssSvPolynomial &svPolynomial); void reportStatus(LocGpsStatusValue status); void reportNmea(const char* nmea, int length); + void reportData(GnssDataNotification& dataNotify, int msInWeek); void reportXtraServer(const char* url1, const char* url2, const char* url3, const int maxlength); void requestXtraData(); @@ -262,6 +266,7 @@ public: void updateEvtMask(); + void updateNmeaMask(uint32_t mask); virtual LocationError setGpsLockSync(GnssConfigGpsLock lock); diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index f75febd3..a72d4b31 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -1896,6 +1896,11 @@ GnssAdapter::updateClientsEventMask() if (it->second.gnssMeasurementsCb != nullptr) { mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; } + if (it->second.gnssDataCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT; + mask |= LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; + updateNmeaMask(mNmeaMask | LOC_NMEA_MASK_DEBUG_V02); + } } /* @@ -2810,7 +2815,9 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask techMask, - bool fromEngineHub) + bool fromEngineHub, + GnssDataNotification* pDataNotify, + int msInWeek) { // if this event is called from QMI LOC API, then send report to engine hub // if sending is successful, we return as we will wait for final report from engine hub @@ -2842,17 +2849,30 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, const GpsLocationExtended mLocationExtended; loc_sess_status mStatus; LocPosTechMask mTechMask; + GnssDataNotification mDataNotify; + int mMsInWeek; + bool mbIsDataValid; inline MsgReportPosition(GnssAdapter& adapter, const UlpLocation& ulpLocation, const GpsLocationExtended& locationExtended, loc_sess_status status, - LocPosTechMask techMask) : + LocPosTechMask techMask, + GnssDataNotification* pDataNotify, + int msInWeek) : LocMsg(), mAdapter(adapter), mUlpLocation(ulpLocation), mLocationExtended(locationExtended), mStatus(status), - mTechMask(techMask) {} + mTechMask(techMask), + mMsInWeek(msInWeek) { + if (pDataNotify != nullptr) { + mDataNotify = *pDataNotify; + mbIsDataValid = true; + } else { + mbIsDataValid = false; + } + } inline virtual void proc() const { // extract bug report info - this returns true if consumed by systemstatus SystemStatus* s = mAdapter.getSystemStatus(); @@ -2861,10 +2881,19 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, s->eventPosition(mUlpLocation, mLocationExtended); } mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask); + if (true == mbIsDataValid) { + if (-1 != mMsInWeek) { + mAdapter.getDataInformation((GnssDataNotification&)mDataNotify, + mMsInWeek); + } + mAdapter.reportData((GnssDataNotification&)mDataNotify); + } } }; - sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask)); + sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, + status, techMask, + pDataNotify, msInWeek)); } bool @@ -3100,6 +3129,54 @@ GnssAdapter::reportNmea(const char* nmea, size_t length) } } +void +GnssAdapter::reportDataEvent(const GnssDataNotification& dataNotify, + int msInWeek) +{ + struct MsgReportData : public LocMsg { + GnssAdapter& mAdapter; + GnssDataNotification mDataNotify; + int mMsInWeek; + inline MsgReportData(GnssAdapter& adapter, + const GnssDataNotification& dataNotify, + int msInWeek) : + LocMsg(), + mAdapter(adapter), + mDataNotify(dataNotify), + mMsInWeek(msInWeek) { + } + inline virtual void proc() const { + if (-1 != mMsInWeek) { + mAdapter.getDataInformation((GnssDataNotification&)mDataNotify, + mMsInWeek); + } + mAdapter.reportData((GnssDataNotification&)mDataNotify); + } + }; + + sendMsg(new MsgReportData(*this, dataNotify, msInWeek)); +} + +void +GnssAdapter::reportData(GnssDataNotification& dataNotify) +{ + for (int sig = 0; sig < GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES; sig++) { + if (GNSS_LOC_DATA_JAMMER_IND_BIT == + (dataNotify.gnssDataMask[sig] & GNSS_LOC_DATA_JAMMER_IND_BIT)) { + LOC_LOGv("jammerInd[%d]=%f", sig, dataNotify.jammerInd[sig]); + } + if (GNSS_LOC_DATA_AGC_BIT == + (dataNotify.gnssDataMask[sig] & GNSS_LOC_DATA_AGC_BIT)) { + LOC_LOGv("agc[%d]=%f", sig, dataNotify.agc[sig]); + } + } + for (auto it = mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssDataCb) { + it->second.gnssDataCb(dataNotify); + } + } +} + bool GnssAdapter::requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* data) { @@ -3995,6 +4072,94 @@ GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int m } } +/* get Data information from system status and fill it */ +void +GnssAdapter::getDataInformation(GnssDataNotification& data, int msInWeek) +{ + SystemStatus* systemstatus = getSystemStatus(); + + LOC_LOGV("%s]: msInWeek=%d", __func__, msInWeek); + if (nullptr != systemstatus) { + SystemStatusReports reports = {}; + systemstatus->getReport(reports, true); + + if ((!reports.mRfAndParams.empty()) && (!reports.mTimeAndClock.empty()) && + (abs(msInWeek - (int)reports.mTimeAndClock.back().mGpsTowMs) < 2000)) { + + for (int sig = GNSS_LOC_SIGNAL_TYPE_GPS_L1CA; + sig < GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES; sig++) { + data.gnssDataMask[sig] = 0; + data.jammerInd[sig] = 0.0; + data.agc[sig] = 0.0; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcGps) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] |= + GNSS_LOC_DATA_AGC_BIT; + data.agc[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] = + reports.mRfAndParams.back().mAgcGps; + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] |= + GNSS_LOC_DATA_AGC_BIT; + data.agc[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] = + reports.mRfAndParams.back().mAgcGps; + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] |= + GNSS_LOC_DATA_AGC_BIT; + data.agc[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] = + reports.mRfAndParams.back().mAgcGps; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerGps) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] |= + GNSS_LOC_DATA_JAMMER_IND_BIT; + data.jammerInd[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] = + (double)reports.mRfAndParams.back().mJammerGps; + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] |= + GNSS_LOC_DATA_JAMMER_IND_BIT; + data.jammerInd[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] = + (double)reports.mRfAndParams.back().mJammerGps; + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] |= + GNSS_LOC_DATA_JAMMER_IND_BIT; + data.jammerInd[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] = + (double)reports.mRfAndParams.back().mJammerGps; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcGlo) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] |= + GNSS_LOC_DATA_AGC_BIT; + data.agc[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] = + reports.mRfAndParams.back().mAgcGlo; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerGlo) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] |= + GNSS_LOC_DATA_JAMMER_IND_BIT; + data.jammerInd[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] = + (double)reports.mRfAndParams.back().mJammerGlo; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcBds) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] |= + GNSS_LOC_DATA_AGC_BIT; + data.agc[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] = + reports.mRfAndParams.back().mAgcBds; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerBds) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] |= + GNSS_LOC_DATA_JAMMER_IND_BIT; + data.jammerInd[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] = + (double)reports.mRfAndParams.back().mJammerBds; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcGal) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] |= + GNSS_LOC_DATA_AGC_BIT; + data.agc[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] = + reports.mRfAndParams.back().mAgcGal; + } + if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerGal) { + data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] |= + GNSS_LOC_DATA_JAMMER_IND_BIT; + data.jammerInd[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] = + (double)reports.mRfAndParams.back().mJammerGal; + } + } + } +} + /* Callbacks registered with loc_net_iface library */ static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn, AGpsBearerType bearerType, void* userDataPtr) { diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 0b0b396c..bf757b47 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -320,10 +320,13 @@ public: const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask techMask, - bool fromEngineHub=false); + bool fromEngineHub = false, + GnssDataNotification* pDataNotify = nullptr, + int msInWeek = -1); virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromEngineHub=false); virtual void reportNmeaEvent(const char* nmea, size_t length); + virtual void reportDataEvent(const GnssDataNotification& dataNotify, int msInWeek); virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data); virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements, int msInWeek); @@ -345,6 +348,7 @@ public: LocPosTechMask techMask); void reportSv(GnssSvNotification& svNotify); void reportNmea(const char* nmea, size_t length); + void reportData(GnssDataNotification& dataNotify); bool requestNiNotify(const GnssNiNotification& notify, const void* data); void reportGnssMeasurementData(const GnssMeasurementsNotification& measurements); void reportGnssSvIdConfig(const GnssSvIdConfig& config); @@ -355,6 +359,8 @@ public: bool getDebugReport(GnssDebugReport& report); /* get AGC information from system status and fill it */ void getAgcInformation(GnssMeasurementsNotification& measurements, int msInWeek); + /* get Data information from system status and fill it */ + void getDataInformation(GnssDataNotification& data, int msInWeek); /*==== SYSTEM STATUS ================================================================*/ inline SystemStatus* getSystemStatus(void) { return mSystemStatus; } diff --git a/location/LocationAPI.cpp b/location/LocationAPI.cpp index 581158bd..9a67f39e 100644 --- a/location/LocationAPI.cpp +++ b/location/LocationAPI.cpp @@ -56,6 +56,7 @@ static bool needsGnssTrackingInfo(LocationCallbacks& locationCallbacks) return (locationCallbacks.gnssLocationInfoCb != nullptr || locationCallbacks.gnssSvCb != nullptr || locationCallbacks.gnssNmeaCb != nullptr || + locationCallbacks.gnssDataCb != nullptr || locationCallbacks.gnssMeasurementsCb != nullptr); } diff --git a/location/LocationAPIClientBase.h b/location/LocationAPIClientBase.h index bcc39f3c..c61e4a83 100644 --- a/location/LocationAPIClientBase.h +++ b/location/LocationAPIClientBase.h @@ -239,6 +239,7 @@ public: inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {} inline virtual void onGnssNmeaCb(GnssNmeaNotification /*gnssNmeaNotification*/) {} + inline virtual void onGnssDataCb(GnssDataNotification /*gnssDataNotification*/) {} inline virtual void onGnssMeasurementsCb( GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {} diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index 1f2a422a..c80c213d 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -542,6 +542,36 @@ typedef enum /**< QZSS satellite. */ } Gnss_LocSvSystemEnumType; +typedef enum { + GNSS_LOC_SIGNAL_TYPE_GPS_L1CA = 0, /**< GPS L1CA Signal */ + GNSS_LOC_SIGNAL_TYPE_GPS_L1C = 1, /**< GPS L1C Signal */ + GNSS_LOC_SIGNAL_TYPE_GPS_L2C_L = 2, /**< GPS L2C_L RF Band */ + GNSS_LOC_SIGNAL_TYPE_GPS_L5_Q = 3, /**< GPS L5_Q RF Band */ + GNSS_LOC_SIGNAL_TYPE_GLONASS_G1 = 4, /**< GLONASS G1 (L1OF) RF Band */ + GNSS_LOC_SIGNAL_TYPE_GLONASS_G2 = 5, /**< GLONASS G2 (L2OF) RF Band */ + GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C = 6, /**< GALILEO E1_C RF Band */ + GNSS_LOC_SIGNAL_TYPE_GALILEO_E5A_Q = 7, /**< GALILEO E5A_Q RF Band */ + GNSS_LOC_SIGNAL_TYPE_GALILEO_E5B_Q = 8, /**< GALILEO E5B_Q RF Band */ + GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I = 9, /**< BEIDOU B1_I RF Band */ + GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1C = 10, /**< BEIDOU B1C RF Band */ + GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2_I = 11, /**< BEIDOU B2_I RF Band */ + GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2A_I = 12, /**< BEIDOU B2A_I RF Band */ + GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA = 13, /**< QZSS L1CA RF Band */ + GNSS_LOC_SIGNAL_TYPE_QZSS_L1S = 14, /**< QZSS L1S RF Band */ + GNSS_LOC_SIGNAL_TYPE_QZSS_L2C_L = 15, /**< QZSS L2C_L RF Band */ + GNSS_LOC_SIGNAL_TYPE_QZSS_L5_Q = 16, /**< QZSS L5_Q RF Band */ + GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA = 17, /**< SBAS L1_CA RF Band */ + GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 18 /**< Maximum number of signal types */ +} Gnss_LocSignalEnumType; + +typedef uint64_t GnssDataMask; +typedef enum { + // Jammer Indicator is available + GNSS_LOC_DATA_JAMMER_IND_BIT = (1ULL << 0), + // AGC is available + GNSS_LOC_DATA_AGC_BIT = (1ULL << 1) +} GnssDataBits; + typedef uint32_t GnssSystemTimeStructTypeFlags; typedef enum { GNSS_SYSTEM_TIME_WEEK_VALID = (1 << 0), @@ -958,6 +988,13 @@ typedef struct { size_t length; // length of the nmea text } GnssNmeaNotification; +typedef struct { + size_t size; // set to sizeof(GnssDataNotification) + GnssDataMask gnssDataMask[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // bitwise OR of GnssDataBits + double jammerInd[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // Jammer Indication + double agc[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // Automatic gain control +} GnssDataNotification; + typedef struct { size_t size; // set to sizeof(GnssMeasurementsNotification) size_t count; // number of items in GnssMeasurements array @@ -1152,6 +1189,13 @@ typedef std::function gnssNmeaCallback; +/* Gives GNSS data, optional can be NULL + gnssDataCallback is called only during a tracking session + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function gnssDataCallback; + /* Gives GNSS Measurements information, optional can be NULL gnssMeasurementsCallback is called only during a tracking session broadcasted to all clients, no matter if a session has started by client */ @@ -1177,6 +1221,7 @@ typedef struct { gnssNiCallback gnssNiCb; // optional gnssSvCallback gnssSvCb; // optional gnssNmeaCallback gnssNmeaCb; // optional + gnssDataCallback gnssDataCb; // optional gnssMeasurementsCallback gnssMeasurementsCb; // optional batchingStatusCallback batchingStatusCb; // optional } LocationCallbacks;