Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include <Constants.h> |
Enrico Granata | 3ba5d22 | 2020-10-21 17:20:00 -0600 | [diff] [blame] | 18 | #include <MockLocation.h> |
Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 19 | #include <Utils.h> |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 20 | #include <aidl/android/hardware/gnss/BnGnss.h> |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 21 | #include <utils/SystemClock.h> |
Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 22 | |
| 23 | namespace android { |
| 24 | namespace hardware { |
| 25 | namespace gnss { |
| 26 | namespace common { |
| 27 | |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 28 | using aidl::android::hardware::gnss::ElapsedRealtime; |
| 29 | using aidl::android::hardware::gnss::GnssClock; |
Yu-Han Yang | 1afbd5f | 2021-11-24 16:39:13 -0800 | [diff] [blame] | 30 | using aidl::android::hardware::gnss::GnssConstellationType; |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 31 | using aidl::android::hardware::gnss::GnssData; |
Yu-Han Yang | 3a75dc0 | 2021-09-27 01:01:06 -0700 | [diff] [blame] | 32 | using aidl::android::hardware::gnss::GnssLocation; |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 33 | using aidl::android::hardware::gnss::GnssMeasurement; |
| 34 | using aidl::android::hardware::gnss::IGnss; |
Yu-Han Yang | 19c2d9b | 2022-01-14 14:45:30 -0800 | [diff] [blame] | 35 | using aidl::android::hardware::gnss::IGnssDebug; |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 36 | using aidl::android::hardware::gnss::IGnssMeasurementCallback; |
Joe Huang | f985398 | 2021-05-08 13:27:29 +0800 | [diff] [blame] | 37 | using aidl::android::hardware::gnss::SatellitePvt; |
Yu-Han Yang | 1afbd5f | 2021-11-24 16:39:13 -0800 | [diff] [blame] | 38 | using GnssSvInfo = aidl::android::hardware::gnss::IGnssCallback::GnssSvInfo; |
| 39 | using GnssSvFlags = aidl::android::hardware::gnss::IGnssCallback::GnssSvFlags; |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 40 | |
Yu-Han Yang | 1afbd5f | 2021-11-24 16:39:13 -0800 | [diff] [blame] | 41 | using GnssSvFlagsV1_0 = V1_0::IGnssCallback::GnssSvFlags; |
Yu-Han Yang | 406cb76 | 2021-12-28 12:14:22 -0800 | [diff] [blame] | 42 | using GnssAgc = aidl::android::hardware::gnss::GnssData::GnssAgc; |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 43 | using GnssMeasurementFlagsV1_0 = V1_0::IGnssMeasurementCallback::GnssMeasurementFlags; |
| 44 | using GnssMeasurementFlagsV2_1 = V2_1::IGnssMeasurementCallback::GnssMeasurementFlags; |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 45 | using GnssMeasurementStateV2_0 = V2_0::IGnssMeasurementCallback::GnssMeasurementState; |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 46 | using ElapsedRealtimeFlags = V2_0::ElapsedRealtimeFlags; |
| 47 | using GnssConstellationTypeV2_0 = V2_0::GnssConstellationType; |
| 48 | using IGnssMeasurementCallbackV2_0 = V2_0::IGnssMeasurementCallback; |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 49 | using GnssSignalType = V2_1::GnssSignalType; |
Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 50 | |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 51 | using GnssDataV2_0 = V2_0::IGnssMeasurementCallback::GnssData; |
| 52 | using GnssDataV2_1 = V2_1::IGnssMeasurementCallback::GnssData; |
| 53 | using GnssSvInfoV1_0 = V1_0::IGnssCallback::GnssSvInfo; |
| 54 | using GnssSvInfoV2_0 = V2_0::IGnssCallback::GnssSvInfo; |
| 55 | using GnssSvInfoV2_1 = V2_1::IGnssCallback::GnssSvInfo; |
| 56 | using GnssAntennaInfo = ::android::hardware::gnss::V2_1::IGnssAntennaInfoCallback::GnssAntennaInfo; |
| 57 | using Row = V2_1::IGnssAntennaInfoCallback::Row; |
| 58 | using Coord = V2_1::IGnssAntennaInfoCallback::Coord; |
| 59 | |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 60 | GnssDataV2_1 Utils::getMockMeasurementV2_1() { |
| 61 | GnssDataV2_0 gnssDataV2_0 = Utils::getMockMeasurementV2_0(); |
| 62 | V2_1::IGnssMeasurementCallback::GnssMeasurement gnssMeasurementV2_1 = { |
| 63 | .v2_0 = gnssDataV2_0.measurements[0], |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 64 | .flags = (uint32_t)(GnssMeasurementFlagsV2_1::HAS_CARRIER_FREQUENCY | |
| 65 | GnssMeasurementFlagsV2_1::HAS_CARRIER_PHASE | |
Yu-Han Yang | 6668eab | 2020-03-03 15:23:50 -0800 | [diff] [blame] | 66 | GnssMeasurementFlagsV2_1::HAS_FULL_ISB | |
| 67 | GnssMeasurementFlagsV2_1::HAS_FULL_ISB_UNCERTAINTY | |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 68 | GnssMeasurementFlagsV2_1::HAS_SATELLITE_ISB | |
| 69 | GnssMeasurementFlagsV2_1::HAS_SATELLITE_ISB_UNCERTAINTY), |
Yu-Han Yang | 6668eab | 2020-03-03 15:23:50 -0800 | [diff] [blame] | 70 | .fullInterSignalBiasNs = 30.0, |
| 71 | .fullInterSignalBiasUncertaintyNs = 250.0, |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 72 | .satelliteInterSignalBiasNs = 20.0, |
| 73 | .satelliteInterSignalBiasUncertaintyNs = 150.0, |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 74 | .basebandCN0DbHz = 25.0, |
| 75 | }; |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 76 | GnssSignalType referenceSignalTypeForIsb = { |
| 77 | .constellation = GnssConstellationTypeV2_0::GPS, |
| 78 | .carrierFrequencyHz = 1.59975e+09, |
| 79 | .codeType = "C", |
| 80 | }; |
| 81 | V2_1::IGnssMeasurementCallback::GnssClock gnssClockV2_1 = { |
| 82 | .v1_0 = gnssDataV2_0.clock, |
| 83 | .referenceSignalTypeForIsb = referenceSignalTypeForIsb, |
| 84 | }; |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 85 | hidl_vec<V2_1::IGnssMeasurementCallback::GnssMeasurement> measurements(1); |
| 86 | measurements[0] = gnssMeasurementV2_1; |
| 87 | GnssDataV2_1 gnssDataV2_1 = { |
| 88 | .measurements = measurements, |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 89 | .clock = gnssClockV2_1, |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 90 | .elapsedRealtime = gnssDataV2_0.elapsedRealtime, |
| 91 | }; |
| 92 | return gnssDataV2_1; |
| 93 | } |
| 94 | |
| 95 | GnssDataV2_0 Utils::getMockMeasurementV2_0() { |
| 96 | V1_0::IGnssMeasurementCallback::GnssMeasurement measurement_1_0 = { |
Yu-Han Yang | 5fe14fa | 2019-12-03 20:54:53 -0800 | [diff] [blame] | 97 | .flags = (uint32_t)GnssMeasurementFlagsV1_0::HAS_CARRIER_FREQUENCY, |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 98 | .svid = (int16_t)6, |
| 99 | .constellation = V1_0::GnssConstellationType::UNKNOWN, |
| 100 | .timeOffsetNs = 0.0, |
| 101 | .receivedSvTimeInNs = 8195997131077, |
| 102 | .receivedSvTimeUncertaintyInNs = 15, |
| 103 | .cN0DbHz = 30.0, |
| 104 | .pseudorangeRateMps = -484.13739013671875, |
Zhanghao | c6b69e7 | 2023-03-11 01:54:11 +0000 | [diff] [blame^] | 105 | .pseudorangeRateUncertaintyMps = 0.1037999987602233, |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 106 | .accumulatedDeltaRangeState = (uint32_t)V1_0::IGnssMeasurementCallback:: |
| 107 | GnssAccumulatedDeltaRangeState::ADR_STATE_UNKNOWN, |
| 108 | .accumulatedDeltaRangeM = 0.0, |
| 109 | .accumulatedDeltaRangeUncertaintyM = 0.0, |
| 110 | .carrierFrequencyHz = 1.59975e+09, |
| 111 | .multipathIndicator = |
| 112 | V1_0::IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_UNKNOWN}; |
| 113 | V1_1::IGnssMeasurementCallback::GnssMeasurement measurement_1_1 = {.v1_0 = measurement_1_0}; |
| 114 | V2_0::IGnssMeasurementCallback::GnssMeasurement measurement_2_0 = { |
| 115 | .v1_1 = measurement_1_1, |
| 116 | .codeType = "C", |
| 117 | .state = GnssMeasurementStateV2_0::STATE_CODE_LOCK | |
| 118 | GnssMeasurementStateV2_0::STATE_BIT_SYNC | |
| 119 | GnssMeasurementStateV2_0::STATE_SUBFRAME_SYNC | |
| 120 | GnssMeasurementStateV2_0::STATE_TOW_DECODED | |
| 121 | GnssMeasurementStateV2_0::STATE_GLO_STRING_SYNC | |
| 122 | GnssMeasurementStateV2_0::STATE_GLO_TOD_DECODED, |
| 123 | .constellation = GnssConstellationTypeV2_0::GLONASS, |
| 124 | }; |
| 125 | |
| 126 | hidl_vec<IGnssMeasurementCallbackV2_0::GnssMeasurement> measurements(1); |
| 127 | measurements[0] = measurement_2_0; |
| 128 | V1_0::IGnssMeasurementCallback::GnssClock clock = {.timeNs = 2713545000000, |
| 129 | .fullBiasNs = -1226701900521857520, |
| 130 | .biasNs = 0.59689998626708984, |
| 131 | .biasUncertaintyNs = 47514.989972114563, |
| 132 | .driftNsps = -51.757811607455452, |
| 133 | .driftUncertaintyNsps = 310.64968328491528, |
| 134 | .hwClockDiscontinuityCount = 1}; |
| 135 | |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 136 | V2_0::ElapsedRealtime timestamp = { |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 137 | .flags = ElapsedRealtimeFlags::HAS_TIMESTAMP_NS | |
| 138 | ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS, |
| 139 | .timestampNs = static_cast<uint64_t>(::android::elapsedRealtimeNano()), |
| 140 | // This is an hardcoded value indicating a 1ms of uncertainty between the two clocks. |
| 141 | // In an actual implementation provide an estimate of the synchronization uncertainty |
| 142 | // or don't set the field. |
| 143 | .timeUncertaintyNs = 1000000}; |
| 144 | |
| 145 | GnssDataV2_0 gnssData = { |
| 146 | .measurements = measurements, .clock = clock, .elapsedRealtime = timestamp}; |
| 147 | return gnssData; |
| 148 | } |
| 149 | |
Yu-Han Yang | c5d4f36 | 2022-11-04 22:55:32 +0000 | [diff] [blame] | 150 | GnssData Utils::getMockMeasurement(const bool enableCorrVecOutputs, const bool enableFullTracking) { |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 151 | aidl::android::hardware::gnss::GnssSignalType signalType = { |
Yu-Han Yang | 1afbd5f | 2021-11-24 16:39:13 -0800 | [diff] [blame] | 152 | .constellation = GnssConstellationType::GLONASS, |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 153 | .carrierFrequencyHz = 1.59975e+09, |
| 154 | .codeType = aidl::android::hardware::gnss::GnssSignalType::CODE_TYPE_C, |
| 155 | }; |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 156 | GnssMeasurement measurement = { |
| 157 | .flags = GnssMeasurement::HAS_AUTOMATIC_GAIN_CONTROL | |
| 158 | GnssMeasurement::HAS_CARRIER_FREQUENCY | GnssMeasurement::HAS_CARRIER_PHASE | |
| 159 | GnssMeasurement::HAS_CARRIER_PHASE_UNCERTAINTY | |
| 160 | GnssMeasurement::HAS_FULL_ISB | GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY | |
| 161 | GnssMeasurement::HAS_SATELLITE_ISB | |
Joe Huang | 0d203ba | 2020-12-07 23:57:48 +0800 | [diff] [blame] | 162 | GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY | |
| 163 | GnssMeasurement::HAS_SATELLITE_PVT, |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 164 | .svid = 13, |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 165 | .signalType = signalType, |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 166 | .receivedSvTimeInNs = 8195997131077, |
| 167 | .receivedSvTimeUncertaintyInNs = 15, |
| 168 | .antennaCN0DbHz = 30.0, |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 169 | .basebandCN0DbHz = 26.5, |
| 170 | .agcLevelDb = 2.3, |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 171 | .pseudorangeRateMps = -484.13739013671875, |
Zhanghao | c6b69e7 | 2023-03-11 01:54:11 +0000 | [diff] [blame^] | 172 | .pseudorangeRateUncertaintyMps = 0.1037999987602233, |
Zhanghao Wen | 28a8edf | 2022-11-17 13:51:25 -0800 | [diff] [blame] | 173 | .accumulatedDeltaRangeState = GnssMeasurement::ADR_STATE_VALID, |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 174 | .accumulatedDeltaRangeM = 1.52, |
| 175 | .accumulatedDeltaRangeUncertaintyM = 2.43, |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 176 | .multipathIndicator = aidl::android::hardware::gnss::GnssMultipathIndicator::UNKNOWN, |
| 177 | .state = GnssMeasurement::STATE_CODE_LOCK | GnssMeasurement::STATE_BIT_SYNC | |
| 178 | GnssMeasurement::STATE_SUBFRAME_SYNC | GnssMeasurement::STATE_TOW_DECODED | |
| 179 | GnssMeasurement::STATE_GLO_STRING_SYNC | |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 180 | GnssMeasurement::STATE_GLO_TOD_DECODED, |
| 181 | .fullInterSignalBiasNs = 21.5, |
| 182 | .fullInterSignalBiasUncertaintyNs = 792.0, |
| 183 | .satelliteInterSignalBiasNs = 233.9, |
| 184 | .satelliteInterSignalBiasUncertaintyNs = 921.2, |
Yu-Han Yang | 19c2d9b | 2022-01-14 14:45:30 -0800 | [diff] [blame] | 185 | .satellitePvt = |
| 186 | { |
| 187 | .flags = SatellitePvt::HAS_POSITION_VELOCITY_CLOCK_INFO | |
| 188 | SatellitePvt::HAS_IONO | SatellitePvt::HAS_TROPO, |
| 189 | .satPosEcef = {.posXMeters = 10442993.1153328, |
| 190 | .posYMeters = -19926932.8051666, |
| 191 | .posZMeters = -12034295.0216203, |
| 192 | .ureMeters = 1000.2345678}, |
| 193 | .satVelEcef = {.velXMps = -478.667183715732, |
| 194 | .velYMps = 1580.68371984114, |
| 195 | .velZMps = -3030.52994449997, |
| 196 | .ureRateMps = 10.2345678}, |
| 197 | .satClockInfo = {.satHardwareCodeBiasMeters = 1.396983861923e-09, |
| 198 | .satTimeCorrectionMeters = -7113.08964331, |
| 199 | .satClkDriftMps = 0}, |
| 200 | .ionoDelayMeters = 3.069949602639317e-08, |
| 201 | .tropoDelayMeters = 3.882265204404031, |
| 202 | .ephemerisSource = |
| 203 | SatellitePvt::SatelliteEphemerisSource::SERVER_LONG_TERM, |
Yu-Han Yang | f20e55c | 2022-02-14 14:20:14 -0800 | [diff] [blame] | 204 | .timeOfClockSeconds = 12345, |
| 205 | .issueOfDataClock = 143, |
| 206 | .timeOfEphemerisSeconds = 9876, |
| 207 | .issueOfDataEphemeris = 48, |
Yu-Han Yang | 19c2d9b | 2022-01-14 14:45:30 -0800 | [diff] [blame] | 208 | }, |
Shinru Han | 4abab50 | 2020-12-09 15:07:18 +0800 | [diff] [blame] | 209 | .correlationVectors = {}}; |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 210 | |
Yipeng Cao | 4e9b3b7 | 2021-01-23 00:29:52 +0000 | [diff] [blame] | 211 | GnssClock clock = {.gnssClockFlags = GnssClock::HAS_FULL_BIAS | GnssClock::HAS_BIAS | |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 212 | GnssClock::HAS_BIAS_UNCERTAINTY | GnssClock::HAS_DRIFT | |
| 213 | GnssClock::HAS_DRIFT_UNCERTAINTY, |
Yuchen He | 3b68169 | 2021-08-10 22:59:47 +0000 | [diff] [blame] | 214 | .timeNs = 2713545000000, |
| 215 | .fullBiasNs = -1226701900521857520, |
| 216 | .biasNs = 0.59689998626708984, |
| 217 | .biasUncertaintyNs = 47514.989972114563, |
| 218 | .driftNsps = -51.757811607455452, |
| 219 | .driftUncertaintyNsps = 310.64968328491528, |
Yu-Han Yang | 4165ed1 | 2022-02-09 14:47:50 -0800 | [diff] [blame] | 220 | .hwClockDiscontinuityCount = 1, |
| 221 | .referenceSignalTypeForIsb = signalType}; |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 222 | |
| 223 | ElapsedRealtime timestamp = { |
| 224 | .flags = ElapsedRealtime::HAS_TIMESTAMP_NS | ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS, |
| 225 | .timestampNs = ::android::elapsedRealtimeNano(), |
| 226 | // This is an hardcoded value indicating a 1ms of uncertainty between the two clocks. |
| 227 | // In an actual implementation provide an estimate of the synchronization uncertainty |
| 228 | // or don't set the field. |
Yu-Han Yang | cfca8a7 | 2020-12-12 09:36:28 -0800 | [diff] [blame] | 229 | .timeUncertaintyNs = 1020400}; |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 230 | |
Shinru Han | 4abab50 | 2020-12-09 15:07:18 +0800 | [diff] [blame] | 231 | if (enableCorrVecOutputs) { |
| 232 | aidl::android::hardware::gnss::CorrelationVector correlationVector1 = { |
| 233 | .frequencyOffsetMps = 10, |
| 234 | .samplingWidthM = 30, |
| 235 | .samplingStartM = 0, |
| 236 | .magnitude = {0, 5000, 10000, 5000, 0, 0, 3000, 0}}; |
| 237 | aidl::android::hardware::gnss::CorrelationVector correlationVector2 = { |
| 238 | .frequencyOffsetMps = 20, |
| 239 | .samplingWidthM = 30, |
Shinru Han | 37f63ed | 2021-08-10 16:53:17 +0800 | [diff] [blame] | 240 | .samplingStartM = -10, |
Shinru Han | 4abab50 | 2020-12-09 15:07:18 +0800 | [diff] [blame] | 241 | .magnitude = {0, 3000, 5000, 3000, 0, 0, 1000, 0}}; |
| 242 | measurement.correlationVectors = {correlationVector1, correlationVector2}; |
| 243 | measurement.flags |= GnssMeasurement::HAS_CORRELATION_VECTOR; |
| 244 | } |
| 245 | |
Yu-Han Yang | 406cb76 | 2021-12-28 12:14:22 -0800 | [diff] [blame] | 246 | GnssAgc gnssAgc1 = { |
| 247 | .agcLevelDb = 3.5, |
| 248 | .constellation = GnssConstellationType::GLONASS, |
| 249 | .carrierFrequencyHz = (int64_t)kGloG1FreqHz, |
| 250 | }; |
| 251 | |
| 252 | GnssAgc gnssAgc2 = { |
| 253 | .agcLevelDb = -5.1, |
| 254 | .constellation = GnssConstellationType::GPS, |
| 255 | .carrierFrequencyHz = (int64_t)kGpsL1FreqHz, |
| 256 | }; |
| 257 | |
| 258 | GnssData gnssData = {.measurements = {measurement}, |
| 259 | .clock = clock, |
| 260 | .elapsedRealtime = timestamp, |
Yu-Han Yang | c5d4f36 | 2022-11-04 22:55:32 +0000 | [diff] [blame] | 261 | .gnssAgcs = std::vector({gnssAgc1, gnssAgc2}), |
| 262 | .isFullTracking = enableFullTracking}; |
Yu-Han Yang | 0483230 | 2020-11-20 09:51:18 -0800 | [diff] [blame] | 263 | return gnssData; |
| 264 | } |
| 265 | |
Yu-Han Yang | 3a75dc0 | 2021-09-27 01:01:06 -0700 | [diff] [blame] | 266 | GnssLocation Utils::getMockLocation() { |
| 267 | ElapsedRealtime elapsedRealtime = { |
| 268 | .flags = ElapsedRealtime::HAS_TIMESTAMP_NS | ElapsedRealtime::HAS_TIME_UNCERTAINTY_NS, |
| 269 | .timestampNs = ::android::elapsedRealtimeNano(), |
| 270 | // This is an hardcoded value indicating a 1ms of uncertainty between the two clocks. |
| 271 | // In an actual implementation provide an estimate of the synchronization uncertainty |
| 272 | // or don't set the field. |
| 273 | .timeUncertaintyNs = 1020400}; |
| 274 | GnssLocation location = {.gnssLocationFlags = 0xFF, |
| 275 | .latitudeDegrees = gMockLatitudeDegrees, |
| 276 | .longitudeDegrees = gMockLongitudeDegrees, |
| 277 | .altitudeMeters = gMockAltitudeMeters, |
| 278 | .speedMetersPerSec = gMockSpeedMetersPerSec, |
| 279 | .bearingDegrees = gMockBearingDegrees, |
| 280 | .horizontalAccuracyMeters = kMockHorizontalAccuracyMeters, |
| 281 | .verticalAccuracyMeters = kMockVerticalAccuracyMeters, |
| 282 | .speedAccuracyMetersPerSecond = kMockSpeedAccuracyMetersPerSecond, |
| 283 | .bearingAccuracyDegrees = kMockBearingAccuracyDegrees, |
| 284 | .timestampMillis = static_cast<int64_t>( |
| 285 | kMockTimestamp + ::android::elapsedRealtimeNano() / 1e6), |
| 286 | .elapsedRealtime = elapsedRealtime}; |
| 287 | return location; |
| 288 | } |
| 289 | |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 290 | V2_0::GnssLocation Utils::getMockLocationV2_0() { |
| 291 | const V2_0::ElapsedRealtime timestamp = { |
| 292 | .flags = V2_0::ElapsedRealtimeFlags::HAS_TIMESTAMP_NS | |
| 293 | V2_0::ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS, |
| 294 | .timestampNs = static_cast<uint64_t>(::android::elapsedRealtimeNano()), |
| 295 | // This is an hardcoded value indicating a 1ms of uncertainty between the two clocks. |
| 296 | // In an actual implementation provide an estimate of the synchronization uncertainty |
| 297 | // or don't set the field. |
| 298 | .timeUncertaintyNs = 1000000}; |
| 299 | |
| 300 | V2_0::GnssLocation location = {.v1_0 = Utils::getMockLocationV1_0(), |
| 301 | .elapsedRealtime = timestamp}; |
Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 302 | return location; |
| 303 | } |
| 304 | |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 305 | V1_0::GnssLocation Utils::getMockLocationV1_0() { |
| 306 | V1_0::GnssLocation location = { |
| 307 | .gnssLocationFlags = 0xFF, |
Enrico Granata | 3ba5d22 | 2020-10-21 17:20:00 -0600 | [diff] [blame] | 308 | .latitudeDegrees = gMockLatitudeDegrees, |
| 309 | .longitudeDegrees = gMockLongitudeDegrees, |
| 310 | .altitudeMeters = gMockAltitudeMeters, |
Enrico Granata | 72a47a2 | 2020-11-13 12:52:07 -0700 | [diff] [blame] | 311 | .speedMetersPerSec = gMockSpeedMetersPerSec, |
| 312 | .bearingDegrees = gMockBearingDegrees, |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 313 | .horizontalAccuracyMeters = kMockHorizontalAccuracyMeters, |
| 314 | .verticalAccuracyMeters = kMockVerticalAccuracyMeters, |
| 315 | .speedAccuracyMetersPerSecond = kMockSpeedAccuracyMetersPerSecond, |
| 316 | .bearingAccuracyDegrees = kMockBearingAccuracyDegrees, |
Yu-Han Yang | bcf3b22 | 2020-12-28 13:32:39 -0800 | [diff] [blame] | 317 | .timestamp = |
| 318 | static_cast<int64_t>(kMockTimestamp + ::android::elapsedRealtimeNano() / 1e6)}; |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 319 | return location; |
| 320 | } |
| 321 | |
Yu-Han Yang | 1afbd5f | 2021-11-24 16:39:13 -0800 | [diff] [blame] | 322 | namespace { |
| 323 | GnssSvInfo getMockSvInfo(int svid, GnssConstellationType type, float cN0DbHz, float basebandCN0DbHz, |
| 324 | float elevationDegrees, float azimuthDegrees, long carrierFrequencyHz) { |
| 325 | GnssSvInfo svInfo = { |
| 326 | .svid = svid, |
| 327 | .constellation = type, |
| 328 | .cN0Dbhz = cN0DbHz, |
| 329 | .basebandCN0DbHz = basebandCN0DbHz, |
| 330 | .elevationDegrees = elevationDegrees, |
| 331 | .azimuthDegrees = azimuthDegrees, |
| 332 | .carrierFrequencyHz = carrierFrequencyHz, |
| 333 | .svFlag = (int)GnssSvFlags::USED_IN_FIX | (int)GnssSvFlags::HAS_EPHEMERIS_DATA | |
| 334 | (int)GnssSvFlags::HAS_ALMANAC_DATA | (int)GnssSvFlags::HAS_CARRIER_FREQUENCY}; |
| 335 | return svInfo; |
| 336 | } |
| 337 | } // anonymous namespace |
| 338 | |
| 339 | std::vector<GnssSvInfo> Utils::getMockSvInfoList() { |
| 340 | std::vector<GnssSvInfo> gnssSvInfoList = { |
| 341 | getMockSvInfo(3, GnssConstellationType::GPS, 32.5, 27.5, 59.1, 166.5, kGpsL1FreqHz), |
| 342 | getMockSvInfo(5, GnssConstellationType::GPS, 27.0, 22.0, 29.0, 56.5, kGpsL1FreqHz), |
| 343 | getMockSvInfo(17, GnssConstellationType::GPS, 30.5, 25.5, 71.0, 77.0, kGpsL5FreqHz), |
| 344 | getMockSvInfo(26, GnssConstellationType::GPS, 24.1, 19.1, 28.0, 253.0, kGpsL5FreqHz), |
| 345 | getMockSvInfo(5, GnssConstellationType::GLONASS, 20.5, 15.5, 11.5, 116.0, kGloG1FreqHz), |
| 346 | getMockSvInfo(17, GnssConstellationType::GLONASS, 21.5, 16.5, 28.5, 186.0, |
| 347 | kGloG1FreqHz), |
| 348 | getMockSvInfo(18, GnssConstellationType::GLONASS, 28.3, 25.3, 38.8, 69.0, kGloG1FreqHz), |
| 349 | getMockSvInfo(10, GnssConstellationType::GLONASS, 25.0, 20.0, 66.0, 247.0, |
| 350 | kGloG1FreqHz), |
| 351 | getMockSvInfo(3, GnssConstellationType::IRNSS, 22.0, 19.7, 35.0, 112.0, kIrnssL5FreqHz), |
| 352 | }; |
| 353 | return gnssSvInfoList; |
| 354 | } |
| 355 | |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 356 | hidl_vec<GnssSvInfoV2_1> Utils::getMockSvInfoListV2_1() { |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 357 | GnssSvInfoV1_0 gnssSvInfoV1_0 = Utils::getMockSvInfoV1_0(3, V1_0::GnssConstellationType::GPS, |
| 358 | 32.5, 59.1, 166.5, kGpsL1FreqHz); |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 359 | GnssSvInfoV2_0 gnssSvInfoV2_0 = |
| 360 | Utils::getMockSvInfoV2_0(gnssSvInfoV1_0, V2_0::GnssConstellationType::GPS); |
| 361 | hidl_vec<GnssSvInfoV2_1> gnssSvInfoList = { |
| 362 | Utils::getMockSvInfoV2_1(gnssSvInfoV2_0, 27.5), |
| 363 | getMockSvInfoV2_1( |
| 364 | getMockSvInfoV2_0(getMockSvInfoV1_0(5, V1_0::GnssConstellationType::GPS, 27.0, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 365 | 29.0, 56.5, kGpsL1FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 366 | V2_0::GnssConstellationType::GPS), |
| 367 | 22.0), |
| 368 | getMockSvInfoV2_1( |
| 369 | getMockSvInfoV2_0(getMockSvInfoV1_0(17, V1_0::GnssConstellationType::GPS, 30.5, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 370 | 71.0, 77.0, kGpsL5FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 371 | V2_0::GnssConstellationType::GPS), |
| 372 | 25.5), |
| 373 | getMockSvInfoV2_1( |
| 374 | getMockSvInfoV2_0(getMockSvInfoV1_0(26, V1_0::GnssConstellationType::GPS, 24.1, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 375 | 28.0, 253.0, kGpsL5FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 376 | V2_0::GnssConstellationType::GPS), |
| 377 | 19.1), |
| 378 | getMockSvInfoV2_1( |
| 379 | getMockSvInfoV2_0(getMockSvInfoV1_0(5, V1_0::GnssConstellationType::GLONASS, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 380 | 20.5, 11.5, 116.0, kGloG1FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 381 | V2_0::GnssConstellationType::GLONASS), |
| 382 | 15.5), |
| 383 | getMockSvInfoV2_1( |
| 384 | getMockSvInfoV2_0(getMockSvInfoV1_0(17, V1_0::GnssConstellationType::GLONASS, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 385 | 21.5, 28.5, 186.0, kGloG1FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 386 | V2_0::GnssConstellationType::GLONASS), |
| 387 | 16.5), |
| 388 | getMockSvInfoV2_1( |
| 389 | getMockSvInfoV2_0(getMockSvInfoV1_0(18, V1_0::GnssConstellationType::GLONASS, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 390 | 28.3, 38.8, 69.0, kGloG1FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 391 | V2_0::GnssConstellationType::GLONASS), |
| 392 | 25.3), |
| 393 | getMockSvInfoV2_1( |
| 394 | getMockSvInfoV2_0(getMockSvInfoV1_0(10, V1_0::GnssConstellationType::GLONASS, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 395 | 25.0, 66.0, 247.0, kGloG1FreqHz), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 396 | V2_0::GnssConstellationType::GLONASS), |
| 397 | 20.0), |
Sasha Kuznetsov | 845f6d5 | 2019-12-04 12:17:50 -0800 | [diff] [blame] | 398 | getMockSvInfoV2_1( |
| 399 | getMockSvInfoV2_0(getMockSvInfoV1_0(3, V1_0::GnssConstellationType::UNKNOWN, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 400 | 22.0, 35.0, 112.0, kIrnssL5FreqHz), |
Sasha Kuznetsov | 845f6d5 | 2019-12-04 12:17:50 -0800 | [diff] [blame] | 401 | V2_0::GnssConstellationType::IRNSS), |
| 402 | 19.7), |
Yu-Han Yang | c06b536 | 2019-10-25 14:14:35 -0700 | [diff] [blame] | 403 | }; |
| 404 | return gnssSvInfoList; |
| 405 | } |
| 406 | |
| 407 | GnssSvInfoV2_1 Utils::getMockSvInfoV2_1(GnssSvInfoV2_0 gnssSvInfoV2_0, float basebandCN0DbHz) { |
| 408 | GnssSvInfoV2_1 gnssSvInfoV2_1 = { |
| 409 | .v2_0 = gnssSvInfoV2_0, |
| 410 | .basebandCN0DbHz = basebandCN0DbHz, |
| 411 | }; |
| 412 | return gnssSvInfoV2_1; |
| 413 | } |
| 414 | |
| 415 | GnssSvInfoV2_0 Utils::getMockSvInfoV2_0(GnssSvInfoV1_0 gnssSvInfoV1_0, |
| 416 | V2_0::GnssConstellationType type) { |
| 417 | GnssSvInfoV2_0 gnssSvInfoV2_0 = { |
| 418 | .v1_0 = gnssSvInfoV1_0, |
| 419 | .constellation = type, |
| 420 | }; |
| 421 | return gnssSvInfoV2_0; |
| 422 | } |
| 423 | |
| 424 | GnssSvInfoV1_0 Utils::getMockSvInfoV1_0(int16_t svid, V1_0::GnssConstellationType type, |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 425 | float cN0DbHz, float elevationDegrees, float azimuthDegrees, |
| 426 | float carrierFrequencyHz) { |
Yu-Han Yang | 1afbd5f | 2021-11-24 16:39:13 -0800 | [diff] [blame] | 427 | GnssSvInfoV1_0 svInfo = { |
| 428 | .svid = svid, |
| 429 | .constellation = type, |
| 430 | .cN0Dbhz = cN0DbHz, |
| 431 | .elevationDegrees = elevationDegrees, |
| 432 | .azimuthDegrees = azimuthDegrees, |
| 433 | .carrierFrequencyHz = carrierFrequencyHz, |
| 434 | .svFlag = GnssSvFlagsV1_0::USED_IN_FIX | GnssSvFlagsV1_0::HAS_EPHEMERIS_DATA | |
| 435 | GnssSvFlagsV1_0::HAS_ALMANAC_DATA | GnssSvFlagsV1_0::HAS_CARRIER_FREQUENCY}; |
Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 436 | return svInfo; |
| 437 | } |
| 438 | |
Sasha Kuznetsov | 768de57 | 2020-02-11 06:00:10 +0000 | [diff] [blame] | 439 | hidl_vec<GnssAntennaInfo> Utils::getMockAntennaInfos() { |
| 440 | GnssAntennaInfo mockAntennaInfo_1 = { |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 441 | .carrierFrequencyMHz = kGpsL1FreqHz * 1e-6, |
Sasha Kuznetsov | 768de57 | 2020-02-11 06:00:10 +0000 | [diff] [blame] | 442 | .phaseCenterOffsetCoordinateMillimeters = Coord{.x = 1, |
| 443 | .xUncertainty = 0.1, |
| 444 | .y = 2, |
| 445 | .yUncertainty = 0.1, |
| 446 | .z = 3, |
| 447 | .zUncertainty = 0.1}, |
| 448 | .phaseCenterVariationCorrectionMillimeters = |
| 449 | { |
| 450 | Row{hidl_vec<double>{1, -1, 5, -2, 3, -1}}, |
| 451 | Row{hidl_vec<double>{-2, 3, 2, 0, 1, 2}}, |
| 452 | Row{hidl_vec<double>{1, 3, 2, -1, -3, 5}}, |
| 453 | }, |
| 454 | .phaseCenterVariationCorrectionUncertaintyMillimeters = |
| 455 | { |
| 456 | Row{hidl_vec<double>{0.1, 0.2, 0.4, 0.1, 0.2, 0.3}}, |
| 457 | Row{hidl_vec<double>{0.3, 0.2, 0.3, 0.6, 0.1, 0.1}}, |
| 458 | Row{hidl_vec<double>{0.1, 0.1, 0.4, 0.2, 0.5, 0.3}}, |
| 459 | }, |
| 460 | .signalGainCorrectionDbi = |
| 461 | { |
| 462 | Row{hidl_vec<double>{2, -3, 1, -3, 0, -4}}, |
| 463 | Row{hidl_vec<double>{1, 0, -4, 1, 3, -2}}, |
| 464 | Row{hidl_vec<double>{3, -2, 0, -2, 3, 0}}, |
| 465 | }, |
| 466 | .signalGainCorrectionUncertaintyDbi = |
| 467 | { |
| 468 | Row{hidl_vec<double>{0.3, 0.1, 0.2, 0.6, 0.1, 0.3}}, |
| 469 | Row{hidl_vec<double>{0.1, 0.1, 0.5, 0.2, 0.3, 0.1}}, |
| 470 | Row{hidl_vec<double>{0.2, 0.4, 0.2, 0.1, 0.1, 0.2}}, |
| 471 | }, |
| 472 | }; |
| 473 | |
| 474 | GnssAntennaInfo mockAntennaInfo_2 = { |
Yu-Han Yang | 703ac96 | 2021-07-20 16:47:37 -0700 | [diff] [blame] | 475 | .carrierFrequencyMHz = kGpsL5FreqHz * 1e-6, |
Sasha Kuznetsov | 768de57 | 2020-02-11 06:00:10 +0000 | [diff] [blame] | 476 | .phaseCenterOffsetCoordinateMillimeters = Coord{.x = 5, |
| 477 | .xUncertainty = 0.1, |
| 478 | .y = 6, |
| 479 | .yUncertainty = 0.1, |
| 480 | .z = 7, |
| 481 | .zUncertainty = 0.1}, |
| 482 | }; |
| 483 | |
| 484 | hidl_vec<GnssAntennaInfo> mockAntennaInfos = { |
| 485 | mockAntennaInfo_1, |
| 486 | mockAntennaInfo_2, |
| 487 | }; |
| 488 | return mockAntennaInfos; |
| 489 | } |
| 490 | |
Yu-Han Yang | a509861 | 2019-02-08 16:22:07 -0800 | [diff] [blame] | 491 | } // namespace common |
| 492 | } // namespace gnss |
| 493 | } // namespace hardware |
| 494 | } // namespace android |