0.3.0
Loading...
Searching...
No Matches
Frequency.cpp
Go to the documentation of this file.
1// This file is part of INSTINCT, the INS Toolkit for Integrated
2// Navigation Concepts and Training by the Institute of Navigation of
3// the University of Stuttgart, Germany.
4//
5// This Source Code Form is subject to the terms of the Mozilla Public
6// License, v. 2.0. If a copy of the MPL was not distributed with this
7// file, You can obtain one at https://mozilla.org/MPL/2.0/.
8
9#include "Frequency.hpp"
10
11#include <algorithm>
12#include <cmath>
13#include <imgui.h>
14#include <imgui_internal.h>
15
16#include "util/Assert.h"
17#include "util/Logger.hpp"
18
19namespace NAV
20{
21
22Frequency Frequency::fromString(const std::string& typeString)
23{
24 if (typeString == "B1" || typeString == "B01" || typeString == "C01") { return B01; }
25 if (typeString == "B2" || typeString == "B08" || typeString == "C08") { return B08; }
26 if (typeString == "B3" || typeString == "B06" || typeString == "C06") { return B06; }
27 if (typeString == "B1-2" || typeString == "B02" || typeString == "C02") { return B02; }
28 if (typeString == "B2a" || typeString == "B05" || typeString == "C05") { return B05; }
29 if (typeString == "B2b" || typeString == "B07" || typeString == "C07") { return B07; }
30 if (typeString == "E1" || typeString == "E01") { return E01; }
31 if (typeString == "E5a" || typeString == "E05") { return E05; }
32 if (typeString == "E6" || typeString == "E06") { return E06; }
33 if (typeString == "E5b" || typeString == "E07") { return E07; }
34 if (typeString == "E5" || typeString == "E08") { return E08; }
35 if (typeString == "L1" || typeString == "G01") { return G01; }
36 if (typeString == "L2" || typeString == "G02") { return G02; }
37 if (typeString == "L5" || typeString == "G05") { return G05; }
38 if (typeString == "I5" || typeString == "I05") { return I05; }
39 if (typeString == "IS" || typeString == "I09") { return I09; }
40 if (typeString == "Q1" || typeString == "J01") { return J01; }
41 if (typeString == "Q2" || typeString == "J02") { return J02; }
42 if (typeString == "Q5" || typeString == "J05") { return J05; }
43 if (typeString == "Q6" || typeString == "QLEX" || typeString == "J06") { return J06; }
44 if (typeString == "G1" || typeString == "R01") { return R01; }
45 if (typeString == "G2" || typeString == "R02") { return R02; }
46 if (typeString == "G3" || typeString == "R03") { return R03; }
47 if (typeString == "G1a" || typeString == "R04") { return R04; }
48 if (typeString == "G2a" || typeString == "R06") { return R06; }
49 if (typeString == "S1" || typeString == "S01") { return S01; }
50 if (typeString == "S5" || typeString == "S05") { return S05; }
51
52 return Freq_None;
53}
54
55Frequency Frequency::fromEnum(Frequency::Enum enumeration)
56{
57 switch (enumeration)
58 {
59 case Frequency::Enum_G01:
60 return G01;
61 case Frequency::Enum_G02:
62 return G02;
63 case Frequency::Enum_G05:
64 return G05;
65 case Frequency::Enum_E01:
66 return E01;
67 case Frequency::Enum_E05:
68 return E05;
69 case Frequency::Enum_E06:
70 return E06;
71 case Frequency::Enum_E07:
72 return E07;
73 case Frequency::Enum_E08:
74 return E08;
75 case Frequency::Enum_R01:
76 return R01;
77 case Frequency::Enum_R02:
78 return R02;
79 case Frequency::Enum_R03:
80 return R03;
81 case Frequency::Enum_R04:
82 return R04;
83 case Frequency::Enum_R06:
84 return R06;
85 case Frequency::Enum_B01:
86 return B01;
87 case Frequency::Enum_B02:
88 return B02;
89 case Frequency::Enum_B05:
90 return B05;
91 case Frequency::Enum_B06:
92 return B06;
93 case Frequency::Enum_B07:
94 return B07;
95 case Frequency::Enum_B08:
96 return B08;
97 case Frequency::Enum_J01:
98 return J01;
99 case Frequency::Enum_J02:
100 return J02;
101 case Frequency::Enum_J05:
102 return J05;
103 case Frequency::Enum_J06:
104 return J06;
105 case Frequency::Enum_I05:
106 return I05;
107 case Frequency::Enum_I09:
108 return I09;
109 case Frequency::Enum_S01:
110 return S01;
111 case Frequency::Enum_S05:
112 return S05;
113 case Frequency::Enum_COUNT:
114 case Frequency::Enum_None:
115 return Freq_None;
116 }
117 return Freq_None;
118}
119
120Frequency::operator std::string() const
121{
122 const std::string filler = " | ";
123 std::string str;
124 if (value & G01)
125 {
126 str += (!str.empty() ? filler : "") + "L1";
127 }
128 if (value & G02)
129 {
130 str += (!str.empty() ? filler : "") + "L2";
131 }
132 if (value & G05)
133 {
134 str += (!str.empty() ? filler : "") + "L5";
135 }
136 if (value & E01)
137 {
138 str += (!str.empty() ? filler : "") + "E1";
139 }
140 if (value & E05)
141 {
142 str += (!str.empty() ? filler : "") + "E5a";
143 }
144 if (value & E06)
145 {
146 str += (!str.empty() ? filler : "") + "E6";
147 }
148 if (value & E07)
149 {
150 str += (!str.empty() ? filler : "") + "E5b";
151 }
152 if (value & E08)
153 {
154 str += (!str.empty() ? filler : "") + "E5";
155 }
156 if (value & R01)
157 {
158 str += (!str.empty() ? filler : "") + "G1";
159 }
160 if (value & R02)
161 {
162 str += (!str.empty() ? filler : "") + "G2";
163 }
164 if (value & R03)
165 {
166 str += (!str.empty() ? filler : "") + "G3";
167 }
168 if (value & R04)
169 {
170 str += (!str.empty() ? filler : "") + "G1a";
171 }
172 if (value & R06)
173 {
174 str += (!str.empty() ? filler : "") + "G2a";
175 }
176 if (value & B01)
177 {
178 str += (!str.empty() ? filler : "") + "B1";
179 }
180 if (value & B08)
181 {
182 str += (!str.empty() ? filler : "") + "B2";
183 }
184 if (value & B06)
185 {
186 str += (!str.empty() ? filler : "") + "B3";
187 }
188 if (value & B02)
189 {
190 str += (!str.empty() ? filler : "") + "B1-2";
191 }
192 if (value & B05)
193 {
194 str += (!str.empty() ? filler : "") + "B2a";
195 }
196 if (value & B07)
197 {
198 str += (!str.empty() ? filler : "") + "B2b";
199 }
200 if (value & J01)
201 {
202 str += (!str.empty() ? filler : "") + "Q1";
203 }
204 if (value & J02)
205 {
206 str += (!str.empty() ? filler : "") + "Q2";
207 }
208 if (value & J05)
209 {
210 str += (!str.empty() ? filler : "") + "Q5";
211 }
212 if (value & J06)
213 {
214 str += (!str.empty() ? filler : "") + "Q6";
215 }
216 if (value & I05)
217 {
218 str += (!str.empty() ? filler : "") + "I5";
219 }
220 if (value & I09)
221 {
222 str += (!str.empty() ? filler : "") + "IS";
223 }
224 if (value & S01)
225 {
226 str += (!str.empty() ? filler : "") + "S1";
227 }
228 if (value & S05)
229 {
230 str += (!str.empty() ? filler : "") + "S5";
231 }
232
233 if (!str.empty())
234 {
235 return str;
236 }
237 return "None";
238}
239
240SatelliteSystem Frequency::GetSatelliteSystemForFrequency(Frequency freq)
241{
242 SatelliteSystem retVal = SatSys_None;
243 for (auto satSys : SatelliteSystem::GetAll())
244 {
245 if (freq & satSys) { retVal |= satSys; }
246 }
247 return retVal;
248}
249
250double Frequency::GetFrequency(Frequency freq, int8_t num)
251{
252 switch (Frequency_(freq))
253 {
254 case B01: // Beidou B1 (1575.42 MHz)
255 return 1575.42e6;
256 case B02: // Beidou B1-2 (1561.098 MHz)
257 return 1561.098e6;
258 case B05: // Beidou B2a (1176.45 MHz)
259 return 1176.45e6;
260 case B06: // Beidou B3 (1268.52 MHz)
261 return 1268.52e6;
262 case B07: // Beidou B2b (1207.14 MHz)
263 return 1207.14e6;
264 case B08: // Beidou B2 (B2a + B2b) (1191.795 MHz)
265 return 1191.795e6;
266 case E01: // Galileo, "E1" (1575.42 MHz)
267 return 1575.42e6;
268 case E05: // Galileo E5a (1176.45 MHz)
269 return 1176.45e6;
270 case E06: // Galileo E6 (1278.75 MHz)
271 return 1278.75e6;
272 case E07: // Galileo E5b (1207.14 MHz)
273 return 1207.14e6;
274 case E08: // Galileo E5 (E5a + E5b) (1191.795 MHz)
275 return 1191.795e6;
276 case G01: // GPS L1 (1575.42 MHz)
277 return 1575.42e6;
278 case G02: // GPS L2 (1227.6 MHz)
279 return 1227.6e6;
280 case G05: // GPS L5 (1176.45 MHz)
281 return 1176.45e6;
282 case I05: // IRNSS L5 (1176.45 MHz)
283 return 1176.45e6;
284 case I09: // IRNSS S (2492.028 MHz)
285 return 2492.028e6;
286 case J01: // QZSS L1 (1575.42 MHz)
287 return 1575.42e6;
288 case J02: // QZSS L2 (1227.6 MHz)
289 return 1227.6e6;
290 case J05: // QZSS L5 (1176.45 MHz)
291 return 1176.45e6;
292 case J06: // QZSS L6 / LEX (1278.75 MHz)
293 return 1278.75e6;
294 case R01: // GLONASS, "G1" (1602 MHZ)
295 INS_ASSERT_USER_ERROR(num >= -7 && num <= 6, "GLONASS G1 frequency numbers have to be in the range [-7, +6] (all satellites launched after 2005)");
296 return (1602.0 + num * 9.0 / 16.0) * 1e6;
297 case R02: // GLONASS, "G2" (1246 MHz)
298 INS_ASSERT_USER_ERROR(num >= -7 && num <= 6, "GLONASS G1 frequency numbers have to be in the range [-7, +6] (all satellites launched after 2005)");
299 return (1246.0 + num * 7.0 / 16.0) * 1e6;
300 case R03: // GLONASS, "G3" (1202.025 MHz)
301 return 1202.025e6;
302 case R04: // GLONASS, "G1a" (1600.995 MHZ)
303 return 1600.995e6;
304 case R06: // GLONASS, "G2a" (1248.06 MHz)
305 return 1248.06e6;
306 case S01: // SBAS L1 (1575.42 MHz)
307 return 1575.42e6;
308 case S05: // SBAS L5 (1176.45 MHz)
309 return 1176.45e6;
310 case Freq_None:
311 return std::nan("");
312 }
313
314 return std::nan("");
315}
316
317Frequency Frequency::GetL1(Frequency freq)
318{
319 switch (Frequency_(freq))
320 {
321 case B01: // Beidou B1 (1575.42 MHz)
322 case B02: // Beidou B1-2 (1561.098 MHz)
323 case B05: // Beidou B2a (1176.45 MHz)
324 case B06: // Beidou B3 (1268.52 MHz)
325 case B07: // Beidou B2b (1207.14 MHz)
326 case B08: // Beidou B2 (B2a + B2b) (1191.795 MHz)
327 return B01;
328 case E01: // Galileo, "E1" (1575.42 MHz)
329 case E05: // Galileo E5a (1176.45 MHz)
330 case E06: // Galileo E6 (1278.75 MHz)
331 case E07: // Galileo E5b (1207.14 MHz)
332 case E08: // Galileo E5 (E5a + E5b) (1191.795 MHz)
333 return E01;
334 case G01: // GPS L1 (1575.42 MHz)
335 case G02: // GPS L2 (1227.6 MHz)
336 case G05: // GPS L5 (1176.45 MHz)
337 return G01;
338 case I05: // IRNSS L5 (1176.45 MHz)
339 case I09: // IRNSS S (2492.028 MHz)
340 return I05;
341 case J01: // QZSS L1 (1575.42 MHz)
342 case J02: // QZSS L2 (1227.6 MHz)
343 case J05: // QZSS L5 (1176.45 MHz)
344 case J06: // QZSS L6 / LEX (1278.75 MHz)
345 return J01;
346 case R01: // GLONASS, "G1" (1602 MHZ)
347 case R02: // GLONASS, "G2" (1246 MHz)
348 case R03: // GLONASS, "G3" (1202.025 MHz)
349 case R04: // GLONASS, "G1a" (1600.995 MHZ)
350 case R06: // GLONASS, "G2a" (1248.06 MHz)
351 return R01;
352 case S01: // SBAS L1 (1575.42 MHz)
353 case S05: // SBAS L5 (1176.45 MHz)
354 return S01;
355 case Freq_None:
356 return Freq_None;
357 }
358
359 return Freq_None;
360}
361
362size_t Frequency::count() const
363{
364 size_t num = 0;
365 if (value & G01) { num += 1; }
366 if (value & G02) { num += 1; }
367 if (value & G05) { num += 1; }
368 if (value & E01) { num += 1; }
369 if (value & E05) { num += 1; }
370 if (value & E06) { num += 1; }
371 if (value & E07) { num += 1; }
372 if (value & E08) { num += 1; }
373 if (value & R01) { num += 1; }
374 if (value & R02) { num += 1; }
375 if (value & R03) { num += 1; }
376 if (value & R04) { num += 1; }
377 if (value & R06) { num += 1; }
378 if (value & B01) { num += 1; }
379 if (value & B02) { num += 1; }
380 if (value & B05) { num += 1; }
381 if (value & B06) { num += 1; }
382 if (value & B07) { num += 1; }
383 if (value & B08) { num += 1; }
384 if (value & J01) { num += 1; }
385 if (value & J02) { num += 1; }
386 if (value & J05) { num += 1; }
387 if (value & J06) { num += 1; }
388 if (value & I05) { num += 1; }
389 if (value & I09) { num += 1; }
390 if (value & S01) { num += 1; }
391 if (value & S05) { num += 1; }
392
393 return num;
394}
395
396Frequency::Enum Frequency::ToEnumeration(Frequency freq)
397{
398 switch (Frequency_(freq))
399 {
400 case Freq_None:
401 return Enum_None;
402 case G01:
403 return Enum_G01;
404 case G02:
405 return Enum_G02;
406 case G05:
407 return Enum_G05;
408 case E01:
409 return Enum_E01;
410 case E05:
411 return Enum_E05;
412 case E06:
413 return Enum_E06;
414 case E07:
415 return Enum_E07;
416 case E08:
417 return Enum_E08;
418 case R01:
419 return Enum_R01;
420 case R02:
421 return Enum_R02;
422 case R03:
423 return Enum_R03;
424 case R04:
425 return Enum_R04;
426 case R06:
427 return Enum_R06;
428 case B01:
429 return Enum_B01;
430 case B02:
431 return Enum_B02;
432 case B05:
433 return Enum_B05;
434 case B06:
435 return Enum_B06;
436 case B07:
437 return Enum_B07;
438 case B08:
439 return Enum_B08;
440 case J01:
441 return Enum_J01;
442 case J02:
443 return Enum_J02;
444 case J05:
445 return Enum_J05;
446 case J06:
447 return Enum_J06;
448 case I05:
449 return Enum_I05;
450 case I09:
451 return Enum_I09;
452 case S01:
453 return Enum_S01;
454 case S05:
455 return Enum_S05;
456 }
457 return Enum_None;
458}
459
460Frequency::Enum Frequency::toEnumeration() const
461{
462 return ToEnumeration(*this);
463}
464
465std::vector<Frequency> Frequency::ToVector(Frequency freq)
466{
467 std::vector<Frequency> v;
468 for (const Frequency& f : GetAll())
469 {
470 if (f.value & freq.value) { v.push_back(f); }
471 }
472 return v;
473}
474
475std::vector<Frequency> Frequency::toVector() const
476{
477 return ToVector(value);
478}
479
480bool Frequency::IsFirstFrequency(const Frequency& freq, const Frequency& filter)
481{
482 return freq.isFirstFrequency(filter);
483}
484
485bool Frequency::isFirstFrequency(const Frequency& filter) const
486{
487 Frequency_ f = filter & getSatSys();
488 f = Frequency_(f ^ value);
489
490 if (f == Freq_None) { return true; }
491
492 auto frequencies = Frequency(f).toVector();
493 return std::ranges::all_of(frequencies,
494 [&](const Frequency& freq) { return value < Frequency_(freq); });
495}
496
497void to_json(json& j, const Frequency& data)
498{
499 j = std::string(data);
500}
501void from_json(const json& j, Frequency& data)
502{
503 data = Frequency::fromString(j.get<std::string>());
504}
505
506bool ShowFrequencySelector(const char* label, Frequency& frequency, bool singleSelect)
507{
508 bool valueChanged = false;
509 if (ImGui::BeginCombo(label, std::string(frequency).c_str(), ImGuiComboFlags_HeightLargest))
510 {
511 if (ImGui::BeginTable(fmt::format("{} Table", label).c_str(), 7, ImGuiTableFlags_BordersInnerV))
512 {
513 for (uint64_t satSys = 0xFF; satSys < 0xFFUL << (7 * 8); satSys = satSys << 8UL)
514 {
515 ImGui::TableSetupColumn(std::string(SatelliteSystem(SatelliteSystem_(satSys))).c_str());
516 }
517 ImGui::TableHeadersRow();
518 for (uint64_t f = 0; f < 8; f++)
519 {
520 ImGui::TableNextRow();
521 for (int c = 0; c < 7; c++)
522 {
523 uint64_t flag = (1UL << (f + static_cast<uint64_t>(c) * 8));
524 auto text = std::string(Frequency(Frequency_(flag)));
525 if (text == "None")
526 {
527 continue;
528 }
529 ImGui::TableSetColumnIndex(c);
530 if (c >= 5)
531 {
532 ImGui::BeginDisabled();
533 }
534 if (singleSelect)
535 {
536 bool selected = flag & Frequency_(frequency);
537 if (ImGui::Checkbox(text.c_str(), &selected) && frequency != Frequency_(flag))
538 {
539 frequency = Frequency_(flag);
540 valueChanged = true;
541 }
542 }
543 else
544 {
545 ImU64 value = Frequency_(frequency);
546 if (ImGui::CheckboxFlags(text.c_str(), &value, flag))
547 {
548 frequency = Frequency_(value);
549 valueChanged = true;
550 }
551 }
552 if (c >= 5)
553 {
554 ImGui::EndDisabled();
555 }
556 }
557 }
558 ImGui::EndTable();
559 }
560 ImGui::EndCombo();
561 }
562 return valueChanged;
563}
564
565} // namespace NAV
566
567std::ostream& operator<<(std::ostream& os, const NAV::Frequency& obj)
568{
569 return os << fmt::format("{}", obj);
570}
Assert.h
Assertion helpers.
INS_ASSERT_USER_ERROR
#define INS_ASSERT_USER_ERROR(_EXP, _MSG)
Assert function with message.
Definition Assert.h:21
json
nlohmann::json json
json namespace
Definition FlowManager.hpp:21
operator<<
std::ostream & operator<<(std::ostream &os, const NAV::Frequency &obj)
Stream insertion operator overload.
Definition Frequency.cpp:567
Frequency.hpp
Frequency definition for different satellite systems.
Logger.hpp
Utility class for logging to console and file.
NAV::Frequency
Frequency definition for different satellite systems.
Definition Frequency.hpp:59
NAV::Frequency::GetAll
static constexpr std::array< Frequency, 27 > GetAll()
Returns a list with all possible frequencies.
Definition Frequency.hpp:183
NAV::Frequency::getSatSys
SatelliteSystem getSatSys() const
Get the satellite system for which this frequency is defined.
Definition Frequency.hpp:152
NAV::Frequency::toVector
std::vector< Frequency > toVector() const
Get a vector representation of the specified Frequency.
Definition Frequency.cpp:475
NAV::Frequency::GetFrequency
static double GetFrequency(Frequency freq, int8_t num)
Get the frequency in [Hz].
Definition Frequency.cpp:250
NAV::Frequency::ToEnumeration
static Enum ToEnumeration(Frequency freq)
Get the continuous enumeration of the specified frequency.
Definition Frequency.cpp:396
NAV::Frequency::fromEnum
static Frequency fromEnum(Enum enumeration)
Constructs a new object from continuous enumeration.
Definition Frequency.cpp:55
NAV::Frequency::Enum
Enum
Satellite System enumeration with continuous range. Not usable as a mask.
Definition Frequency.hpp:63
NAV::Frequency::Enum_R02
@ Enum_R02
GLONASS, "G2" (1246 MHz).
Definition Frequency.hpp:73
NAV::Frequency::Enum_R03
@ Enum_R03
GLONASS, "G3" (1202.025 MHz).
Definition Frequency.hpp:74
NAV::Frequency::Enum_None
@ Enum_None
No Frequency.
Definition Frequency.hpp:92
NAV::Frequency::Enum_B08
@ Enum_B08
Beidou B2 (B2a + B2b) (1191.795MHz).
Definition Frequency.hpp:82
NAV::Frequency::Enum_J05
@ Enum_J05
QZSS L5 (1176.45 MHz).
Definition Frequency.hpp:85
NAV::Frequency::Enum_COUNT
@ Enum_COUNT
Count variable.
Definition Frequency.hpp:91
NAV::Frequency::Enum_E08
@ Enum_E08
Galileo E5 (E5a + E5b) (1191.795MHz).
Definition Frequency.hpp:71
NAV::Frequency::Enum_E01
@ Enum_E01
Galileo, "E1" (1575.42 MHz).
Definition Frequency.hpp:67
NAV::Frequency::Enum_B05
@ Enum_B05
Beidou B2a (1176.45 MHz).
Definition Frequency.hpp:79
NAV::Frequency::Enum_B07
@ Enum_B07
Beidou B2b (1207.14 MHz).
Definition Frequency.hpp:81
NAV::Frequency::Enum_R06
@ Enum_R06
GLONASS, "G2a" (1248.06 MHz).
Definition Frequency.hpp:76
NAV::Frequency::Enum_R01
@ Enum_R01
GLONASS, "G1" (1602 MHZ).
Definition Frequency.hpp:72
NAV::Frequency::Enum_R04
@ Enum_R04
GLONASS, "G1a" (1600.995 MHZ).
Definition Frequency.hpp:75
NAV::Frequency::Enum_S01
@ Enum_S01
SBAS L1 (1575.42 MHz).
Definition Frequency.hpp:89
NAV::Frequency::Enum_G05
@ Enum_G05
GPS L5 (1176.45 MHz).
Definition Frequency.hpp:66
NAV::Frequency::Enum_E07
@ Enum_E07
Galileo E5b (1207.14 MHz).
Definition Frequency.hpp:70
NAV::Frequency::Enum_G02
@ Enum_G02
GPS L2 (1227.6 MHz).
Definition Frequency.hpp:65
NAV::Frequency::Enum_G01
@ Enum_G01
GPS L1 (1575.42 MHz).
Definition Frequency.hpp:64
NAV::Frequency::Enum_I05
@ Enum_I05
IRNSS L5 (1176.45 MHz).
Definition Frequency.hpp:87
NAV::Frequency::Enum_I09
@ Enum_I09
IRNSS S (2492.028 MHz).
Definition Frequency.hpp:88
NAV::Frequency::Enum_S05
@ Enum_S05
SBAS L5 (1176.45 MHz).
Definition Frequency.hpp:90
NAV::Frequency::Enum_B02
@ Enum_B02
Beidou B1-2 (1561.098 MHz).
Definition Frequency.hpp:78
NAV::Frequency::Enum_J02
@ Enum_J02
QZSS L2 (1227.6 MHz).
Definition Frequency.hpp:84
NAV::Frequency::Enum_J06
@ Enum_J06
QZSS L6 / LEX (1278.75 MHz).
Definition Frequency.hpp:86
NAV::Frequency::Enum_E05
@ Enum_E05
Galileo E5a (1176.45 MHz).
Definition Frequency.hpp:68
NAV::Frequency::Enum_E06
@ Enum_E06
Galileo E6 (1278.75 MHz).
Definition Frequency.hpp:69
NAV::Frequency::Enum_J01
@ Enum_J01
QZSS L1 (1575.42 MHz).
Definition Frequency.hpp:83
NAV::Frequency::Enum_B06
@ Enum_B06
Beidou B3 (1268.52 MHz).
Definition Frequency.hpp:80
NAV::Frequency::Enum_B01
@ Enum_B01
Beidou B1 (1575.42 MHz).
Definition Frequency.hpp:77
NAV::Frequency::fromString
static Frequency fromString(const std::string &typeString)
Construct new object from std::string.
Definition Frequency.cpp:22
NAV::Frequency::IsFirstFrequency
static bool IsFirstFrequency(const Frequency &freq, const Frequency &filter)
Checks wether the given frequency is the first in the filter (per system)
Definition Frequency.cpp:480
NAV::Frequency::toEnumeration
Enum toEnumeration() const
Returns a continuous enumeration of the object.
Definition Frequency.cpp:460
NAV::Frequency::isFirstFrequency
bool isFirstFrequency(const Frequency &filter) const
Checks wether the frequency is the first in the filter (per system)
Definition Frequency.cpp:485
NAV::Frequency::Frequency
constexpr Frequency()=default
Default Constructor.
NAV::Frequency::value
Frequency_ value
Internal value.
Definition Frequency.hpp:219
NAV::Frequency::GetL1
static Frequency GetL1(Frequency freq)
Returns the L1 Frequency for each constellation.
Definition Frequency.cpp:317
NAV::Frequency::ToVector
static std::vector< Frequency > ToVector(Frequency freq)
Get a vector representation of the specified Frequency.
Definition Frequency.cpp:465
NAV::Frequency::count
size_t count() const
Counts the amount of frequencies contained.
Definition Frequency.cpp:362
NAV::Frequency::GetSatelliteSystemForFrequency
static SatelliteSystem GetSatelliteSystemForFrequency(Frequency freq)
Get the Time System of the specified Frequency.
Definition Frequency.cpp:240
NAV::to_json
void to_json(json &j, const Node &node)
Converts the provided node into a json object.
Definition Node.cpp:990
NAV::Frequency_
Frequency_
Enumerate for GNSS frequencies.
Definition Frequency.hpp:26
NAV::E07
@ E07
Galileo E5b (1207.14 MHz).
Definition Frequency.hpp:34
NAV::R03
@ R03
GLONASS, "G3" (1202.025 MHz).
Definition Frequency.hpp:38
NAV::J01
@ J01
QZSS L1 (1575.42 MHz).
Definition Frequency.hpp:47
NAV::B02
@ B02
Beidou B1-2 (B1I) (1561.098 MHz).
Definition Frequency.hpp:42
NAV::S01
@ S01
SBAS L1 (1575.42 MHz).
Definition Frequency.hpp:53
NAV::E06
@ E06
Galileo E6 (1278.75 MHz).
Definition Frequency.hpp:33
NAV::Freq_None
@ Freq_None
None.
Definition Frequency.hpp:27
NAV::I09
@ I09
IRNSS S (2492.028 MHz).
Definition Frequency.hpp:52
NAV::B05
@ B05
Beidou B2a (1176.45 MHz).
Definition Frequency.hpp:43
NAV::I05
@ I05
IRNSS L5 (1176.45 MHz).
Definition Frequency.hpp:51
NAV::R02
@ R02
GLONASS, "G2" (1246 MHz).
Definition Frequency.hpp:37
NAV::B08
@ B08
Beidou B2 (B2a + B2b) (1191.795MHz).
Definition Frequency.hpp:46
NAV::R06
@ R06
GLONASS, "G2a" (1248.06 MHz).
Definition Frequency.hpp:40
NAV::E01
@ E01
Galileo, "E1" (1575.42 MHz).
Definition Frequency.hpp:31
NAV::B06
@ B06
Beidou B3 (1268.52 MHz).
Definition Frequency.hpp:44
NAV::E05
@ E05
Galileo E5a (1176.45 MHz).
Definition Frequency.hpp:32
NAV::S05
@ S05
SBAS L5 (1176.45 MHz).
Definition Frequency.hpp:54
NAV::G02
@ G02
GPS L2 (1227.6 MHz).
Definition Frequency.hpp:29
NAV::R01
@ R01
GLONASS, "G1" (1602 MHZ).
Definition Frequency.hpp:36
NAV::G01
@ G01
GPS L1 (1575.42 MHz).
Definition Frequency.hpp:28
NAV::B01
@ B01
Beidou B1 (1575.42 MHz).
Definition Frequency.hpp:41
NAV::J05
@ J05
QZSS L5 (1176.45 MHz).
Definition Frequency.hpp:49
NAV::J02
@ J02
QZSS L2 (1227.6 MHz).
Definition Frequency.hpp:48
NAV::B07
@ B07
Beidou B2b (B2I) (1207.14 MHz).
Definition Frequency.hpp:45
NAV::R04
@ R04
GLONASS, "G1a" (1600.995 MHZ).
Definition Frequency.hpp:39
NAV::E08
@ E08
Galileo E5 (E5a + E5b) (1191.795MHz).
Definition Frequency.hpp:35
NAV::J06
@ J06
QZSS L6 / LEX (1278.75 MHz).
Definition Frequency.hpp:50
NAV::G05
@ G05
GPS L5 (1176.45 MHz).
Definition Frequency.hpp:30
NAV::ShowFrequencySelector
bool ShowFrequencySelector(const char *label, Frequency &frequency, bool singleSelect)
Shows a ComboBox to select GNSS frequencies.
Definition Frequency.cpp:506
NAV::from_json
void from_json(const json &j, Node &node)
Converts the provided json object into a node object.
Definition Node.cpp:1007
NAV::SatelliteSystem_
SatelliteSystem_
Satellite System enumeration.
Definition SatelliteSystem.hpp:31
NAV::SatSys_None
@ SatSys_None
No Satellite system.
Definition SatelliteSystem.hpp:32
NAV::SatelliteSystem
Satellite System type.
Definition SatelliteSystem.hpp:44
NAV::SatelliteSystem::GetAll
static std::vector< SatelliteSystem > GetAll()
Returns a list with all possible satellite systems.
Definition SatelliteSystem.cpp:306