You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
444 lines
13 KiB
444 lines
13 KiB
/* Copyright (c) 2017, The Linux Foundation. All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions are |
|
* met: |
|
* * Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* * Redistributions in binary form must reproduce the above |
|
* copyright notice, this list of conditions and the following |
|
* disclaimer in the documentation and/or other materials provided |
|
* with the distribution. |
|
* * Neither the name of The Linux Foundation, nor the names of its |
|
* contributors may be used to endorse or promote products derived |
|
* from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* |
|
*/ |
|
#ifndef __SYSTEM_STATUS__ |
|
#define __SYSTEM_STATUS__ |
|
|
|
#include <stdint.h> |
|
#include <vector> |
|
#include <gps_extended_c.h> |
|
|
|
#define GPS_MIN (1) //1-32 |
|
#define SBAS_MIN (33) |
|
#define GLO_MIN (65) //65-88 |
|
#define QZSS_MIN (193) //193-197 |
|
#define BDS_MIN (201) //201-237 |
|
#define GAL_MIN (301) //301-336 |
|
|
|
#define GPS_NUM (32) |
|
#define SBAS_NUM (32) |
|
#define GLO_NUM (24) |
|
#define QZSS_NUM (5) |
|
#define BDS_NUM (37) |
|
#define GAL_NUM (36) |
|
#define SV_ALL_NUM (GPS_NUM+GLO_NUM+QZSS_NUM+BDS_NUM+GAL_NUM) //=134 |
|
|
|
namespace loc_core |
|
{ |
|
|
|
/****************************************************************************** |
|
SystemStatus report data structure |
|
******************************************************************************/ |
|
class SystemStatusItemBase |
|
{ |
|
public: |
|
timespec mUtcTime; // UTC timestamp when this info was last updated |
|
timespec mUtcReported; // UTC timestamp when this info was reported |
|
|
|
SystemStatusItemBase() { |
|
timeval tv; |
|
gettimeofday(&tv, NULL); |
|
mUtcTime.tv_sec = tv.tv_sec; |
|
mUtcTime.tv_nsec = tv.tv_usec *1000ULL; |
|
mUtcReported = mUtcTime; |
|
}; |
|
virtual ~SystemStatusItemBase() { }; |
|
virtual void dump(void) { }; |
|
}; |
|
|
|
class SystemStatusLocation : public SystemStatusItemBase |
|
{ |
|
public: |
|
bool mValid; |
|
UlpLocation mLocation; |
|
GpsLocationExtended mLocationEx; |
|
inline SystemStatusLocation() : |
|
mValid(false) {} |
|
inline SystemStatusLocation(const UlpLocation& location, |
|
const GpsLocationExtended& locationEx) : |
|
mValid(true), |
|
mLocation(location), |
|
mLocationEx(locationEx) { } |
|
bool equals(SystemStatusLocation& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWM1; |
|
class SystemStatusTimeAndClock : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint16_t mGpsWeek; |
|
uint32_t mGpsTowMs; |
|
uint8_t mTimeValid; |
|
uint8_t mTimeSource; |
|
int32_t mTimeUnc; |
|
int32_t mClockFreqBias; |
|
int32_t mClockFreqBiasUnc; |
|
int32_t mLeapSeconds; |
|
int32_t mLeapSecUnc; |
|
inline SystemStatusTimeAndClock() : |
|
mGpsWeek(0), |
|
mGpsTowMs(0), |
|
mTimeValid(0), |
|
mTimeSource(0), |
|
mTimeUnc(0), |
|
mClockFreqBias(0), |
|
mClockFreqBiasUnc(0), |
|
mLeapSeconds(0), |
|
mLeapSecUnc(0) {} |
|
inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea); |
|
bool equals(SystemStatusTimeAndClock& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusXoState : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint8_t mXoState; |
|
inline SystemStatusXoState() : |
|
mXoState(0) {} |
|
inline SystemStatusXoState(const SystemStatusPQWM1& nmea); |
|
bool equals(SystemStatusXoState& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusRfAndParams : public SystemStatusItemBase |
|
{ |
|
public: |
|
int32_t mPgaGain; |
|
uint32_t mGpsBpAmpI; |
|
uint32_t mGpsBpAmpQ; |
|
uint32_t mAdcI; |
|
uint32_t mAdcQ; |
|
uint32_t mJammerGps; |
|
uint32_t mJammerGlo; |
|
uint32_t mJammerBds; |
|
uint32_t mJammerGal; |
|
double mAgcGps; |
|
double mAgcGlo; |
|
double mAgcBds; |
|
double mAgcGal; |
|
inline SystemStatusRfAndParams() : |
|
mPgaGain(0), |
|
mGpsBpAmpI(0), |
|
mGpsBpAmpQ(0), |
|
mAdcI(0), |
|
mAdcQ(0), |
|
mJammerGps(0), |
|
mJammerGlo(0), |
|
mJammerBds(0), |
|
mJammerGal(0), |
|
mAgcGps(0), |
|
mAgcGlo(0), |
|
mAgcBds(0), |
|
mAgcGal(0) {} |
|
inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea); |
|
bool equals(SystemStatusRfAndParams& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusErrRecovery : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint32_t mRecErrorRecovery; |
|
inline SystemStatusErrRecovery() : |
|
mRecErrorRecovery(0) {}; |
|
inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea); |
|
bool equals(SystemStatusErrRecovery& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP1; |
|
class SystemStatusInjectedPosition : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint8_t mEpiValidity; |
|
float mEpiLat; |
|
float mEpiLon; |
|
float mEpiAlt; |
|
float mEpiHepe; |
|
float mEpiAltUnc; |
|
uint8_t mEpiSrc; |
|
inline SystemStatusInjectedPosition() : |
|
mEpiValidity(0), |
|
mEpiLat(0), |
|
mEpiLon(0), |
|
mEpiAlt(0), |
|
mEpiHepe(0), |
|
mEpiAltUnc(0), |
|
mEpiSrc(0) {} |
|
inline SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea); |
|
bool equals(SystemStatusInjectedPosition& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP2; |
|
class SystemStatusBestPosition : public SystemStatusItemBase |
|
{ |
|
public: |
|
bool mValid; |
|
float mBestLat; |
|
float mBestLon; |
|
float mBestAlt; |
|
float mBestHepe; |
|
float mBestAltUnc; |
|
inline SystemStatusBestPosition() : |
|
mValid(false), |
|
mBestLat(0), |
|
mBestLon(0), |
|
mBestAlt(0), |
|
mBestHepe(0), |
|
mBestAltUnc(0) {} |
|
inline SystemStatusBestPosition(const SystemStatusPQWP2& nmea); |
|
bool equals(SystemStatusBestPosition& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP3; |
|
class SystemStatusXtra : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint8_t mXtraValidMask; |
|
uint32_t mGpsXtraAge; |
|
uint32_t mGloXtraAge; |
|
uint32_t mBdsXtraAge; |
|
uint32_t mGalXtraAge; |
|
uint32_t mQzssXtraAge; |
|
uint32_t mGpsXtraValid; |
|
uint32_t mGloXtraValid; |
|
uint64_t mBdsXtraValid; |
|
uint64_t mGalXtraValid; |
|
uint8_t mQzssXtraValid; |
|
inline SystemStatusXtra() : |
|
mXtraValidMask(0), |
|
mGpsXtraAge(0), |
|
mGloXtraAge(0), |
|
mBdsXtraAge(0), |
|
mGalXtraAge(0), |
|
mQzssXtraAge(0), |
|
mGpsXtraValid(0), |
|
mGloXtraValid(0), |
|
mBdsXtraValid(0ULL), |
|
mGalXtraValid(0ULL), |
|
mQzssXtraValid(0) {} |
|
inline SystemStatusXtra(const SystemStatusPQWP3& nmea); |
|
bool equals(SystemStatusXtra& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP4; |
|
class SystemStatusEphemeris : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint32_t mGpsEpheValid; |
|
uint32_t mGloEpheValid; |
|
uint64_t mBdsEpheValid; |
|
uint64_t mGalEpheValid; |
|
uint8_t mQzssEpheValid; |
|
inline SystemStatusEphemeris() : |
|
mGpsEpheValid(0), |
|
mGloEpheValid(0), |
|
mBdsEpheValid(0ULL), |
|
mGalEpheValid(0ULL), |
|
mQzssEpheValid(0) {} |
|
inline SystemStatusEphemeris(const SystemStatusPQWP4& nmea); |
|
bool equals(SystemStatusEphemeris& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP5; |
|
class SystemStatusSvHealth : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint32_t mGpsUnknownMask; |
|
uint32_t mGloUnknownMask; |
|
uint64_t mBdsUnknownMask; |
|
uint64_t mGalUnknownMask; |
|
uint8_t mQzssUnknownMask; |
|
uint32_t mGpsGoodMask; |
|
uint32_t mGloGoodMask; |
|
uint64_t mBdsGoodMask; |
|
uint64_t mGalGoodMask; |
|
uint8_t mQzssGoodMask; |
|
uint32_t mGpsBadMask; |
|
uint32_t mGloBadMask; |
|
uint64_t mBdsBadMask; |
|
uint64_t mGalBadMask; |
|
uint8_t mQzssBadMask; |
|
inline SystemStatusSvHealth() : |
|
mGpsUnknownMask(0), |
|
mGloUnknownMask(0), |
|
mBdsUnknownMask(0ULL), |
|
mGalUnknownMask(0ULL), |
|
mQzssUnknownMask(0), |
|
mGpsGoodMask(0), |
|
mGloGoodMask(0), |
|
mBdsGoodMask(0ULL), |
|
mGalGoodMask(0ULL), |
|
mQzssGoodMask(0), |
|
mGpsBadMask(0), |
|
mGloBadMask(0), |
|
mBdsBadMask(0ULL), |
|
mGalBadMask(0ULL), |
|
mQzssBadMask(0) {} |
|
inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea); |
|
bool equals(SystemStatusSvHealth& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP6; |
|
class SystemStatusPdr : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint32_t mFixInfoMask; |
|
inline SystemStatusPdr() : |
|
mFixInfoMask(0) {} |
|
inline SystemStatusPdr(const SystemStatusPQWP6& nmea); |
|
bool equals(SystemStatusPdr& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWP7; |
|
struct SystemStatusNav |
|
{ |
|
GnssEphemerisType mType; |
|
GnssEphemerisSource mSource; |
|
int32_t mAgeSec; |
|
}; |
|
|
|
class SystemStatusNavData : public SystemStatusItemBase |
|
{ |
|
public: |
|
SystemStatusNav mNav[SV_ALL_NUM]; |
|
inline SystemStatusNavData() { |
|
for (uint32_t i=0; i<SV_ALL_NUM; i++) { |
|
mNav[i].mType = GNSS_EPH_TYPE_UNKNOWN; |
|
mNav[i].mSource = GNSS_EPH_SOURCE_UNKNOWN; |
|
mNav[i].mAgeSec = 0; |
|
} |
|
} |
|
inline SystemStatusNavData(const SystemStatusPQWP7& nmea); |
|
bool equals(SystemStatusNavData& peer); |
|
void dump(void); |
|
}; |
|
|
|
class SystemStatusPQWS1; |
|
class SystemStatusPositionFailure : public SystemStatusItemBase |
|
{ |
|
public: |
|
uint32_t mFixInfoMask; |
|
uint32_t mHepeLimit; |
|
inline SystemStatusPositionFailure() : |
|
mFixInfoMask(0), |
|
mHepeLimit(0) {} |
|
inline SystemStatusPositionFailure(const SystemStatusPQWS1& nmea); |
|
bool equals(SystemStatusPositionFailure& peer); |
|
void dump(void); |
|
}; |
|
|
|
/****************************************************************************** |
|
SystemStatusReports |
|
******************************************************************************/ |
|
class SystemStatusReports |
|
{ |
|
public: |
|
std::vector<SystemStatusLocation> mLocation; |
|
|
|
std::vector<SystemStatusTimeAndClock> mTimeAndClock; |
|
std::vector<SystemStatusXoState> mXoState; |
|
std::vector<SystemStatusRfAndParams> mRfAndParams; |
|
std::vector<SystemStatusErrRecovery> mErrRecovery; |
|
|
|
std::vector<SystemStatusInjectedPosition> mInjectedPosition; |
|
std::vector<SystemStatusBestPosition> mBestPosition; |
|
std::vector<SystemStatusXtra> mXtra; |
|
std::vector<SystemStatusEphemeris> mEphemeris; |
|
std::vector<SystemStatusSvHealth> mSvHealth; |
|
std::vector<SystemStatusPdr> mPdr; |
|
std::vector<SystemStatusNavData> mNavData; |
|
|
|
std::vector<SystemStatusPositionFailure> mPositionFailure; |
|
}; |
|
|
|
/****************************************************************************** |
|
SystemStatus |
|
******************************************************************************/ |
|
class SystemStatus |
|
{ |
|
static pthread_mutex_t mMutexSystemStatus; |
|
|
|
static const uint32_t maxLocation = 5; |
|
|
|
static const uint32_t maxTimeAndClock = 5; |
|
static const uint32_t maxXoState = 5; |
|
static const uint32_t maxRfAndParams = 5; |
|
static const uint32_t maxErrRecovery = 5; |
|
|
|
static const uint32_t maxInjectedPosition = 5; |
|
static const uint32_t maxBestPosition = 5; |
|
static const uint32_t maxXtra = 5; |
|
static const uint32_t maxEphemeris = 5; |
|
static const uint32_t maxSvHealth = 5; |
|
static const uint32_t maxPdr = 5; |
|
static const uint32_t maxNavData = 5; |
|
|
|
static const uint32_t maxPositionFailure = 5; |
|
|
|
SystemStatusReports mCache; |
|
|
|
bool setLocation(const UlpLocation& location); |
|
|
|
bool setTimeAndCLock(const SystemStatusPQWM1& nmea); |
|
bool setXoState(const SystemStatusPQWM1& nmea); |
|
bool setRfAndParams(const SystemStatusPQWM1& nmea); |
|
bool setErrRecovery(const SystemStatusPQWM1& nmea); |
|
|
|
bool setInjectedPosition(const SystemStatusPQWP1& nmea); |
|
bool setBestPosition(const SystemStatusPQWP2& nmea); |
|
bool setXtra(const SystemStatusPQWP3& nmea); |
|
bool setEphemeris(const SystemStatusPQWP4& nmea); |
|
bool setSvHealth(const SystemStatusPQWP5& nmea); |
|
bool setPdr(const SystemStatusPQWP6& nmea); |
|
bool setNavData(const SystemStatusPQWP7& nmea); |
|
|
|
bool setPositionFailure(const SystemStatusPQWS1& nmea); |
|
|
|
public: |
|
SystemStatus(); |
|
~SystemStatus() { } |
|
|
|
bool eventPosition(const UlpLocation& location,const GpsLocationExtended& locationEx); |
|
bool setNmeaString(const char *data, uint32_t len); |
|
bool getReport(SystemStatusReports& reports, bool isLatestonly = false) const; |
|
bool setDefaultReport(void); |
|
}; |
|
|
|
} // namespace loc_core |
|
|
|
#endif //__SYSTEM_STATUS__ |
|
|
|
|