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